#include <iostream>
#include <map>

using namespace std;

int main()
{
    int h, w, n;
    int x, y, k;
    char d;
    int start, tmp, lod, pozice;
    int prekryteLode = 0;
    int prekrytaPole = 0;
    int pocetLodi = -1;

    cin >> h;
    cin >> w;
    cin >> n;

    map<int, int> lode;
    pair<int, int> grid[250000];

    while (cin >> x)
    {
        cin >> y;
        cin >> k;
        cin >> d;

        start = x * y;
        pocetLodi++;
        switch (d)
        {
        case 'L':
            for (int i = 0; i < k; i++)
            {
                pozice = start - i * 500;
                if (tmp = grid[pozice].first)
                { // obsazeno
                    if (tmp > 1)
                    {
                        if ((i > 0) && (i < (k - 1)))
                        {
                            // kryje se stred
                            cout << "No" << endl;
                            return 0;
                        }
                    }
                    else
                    { // oznaceni pole
                        if (i > 0 && i < (k - 1))
                        {
                            grid[pozice].first = 2;
                        }
                        else
                        {
                            grid[pozice].first = 1;
                        }
                    }
                    // tmp == 1
                    if (!lode[lod = grid[pozice].second])
                    { // neprekryvala se
                        prekryteLode += 2;
                        prekrytaPole++;
                        lode[lod] = 1;
                        lode[pocetLodi] = 1;
                    }
                    else
                    { // prekryvala se
                        prekryteLode++;
                        prekrytaPole++;
                        lode[pocetLodi] = 1;
                    }
                }
                else
                { // prazdne pole
                    grid[pozice].first = 1;
                }
            }
            break;

        case 'R':
            for (int i = 0; i < k; i++)
            {
                pozice = start + i * 500;
                if (tmp = grid[pozice].first)
                { // obsazeno
                    if (tmp > 1)
                    {
                        if (i > 0 && i < (k - 1))
                        {
                            // kryje se stred
                            cout << "No" << endl;
                            return 0;
                        }
                    }
                    else
                    { // oznaceni pole
                        if (i > 0 && i < (k - 1))
                        {
                            grid[pozice].first = 2;
                        }
                        else
                        {
                            grid[pozice].first = 1;
                        }
                    }
                    // tmp == 1
                    if (!lode[lod = grid[pozice].second])
                    { // neprekryvala se
                        prekryteLode += 2;
                        prekrytaPole++;
                        lode[lod] = 1;
                        lode[pocetLodi] = 1;
                    }
                    else
                    { // prekryvala se
                        prekryteLode++;
                        prekrytaPole++;
                        lode[pocetLodi] = 1;
                    }
                }
                else
                { // prazdne pole
                    grid[pozice].first = 1;
                }
            }
            break;

        case 'U':
            for (int i = 0; i < k; i++)
            {
                pozice = start + i;
                if (tmp = grid[pozice].first)
                { // obsazeno
                    if (tmp > 1)
                    {
                        if (i > 0 && i < (k - 1))
                        {
                            // kryje se stred
                            cout << "No" << endl;
                            return 0;
                        }
                    }
                    else
                    { // oznaceni pole
                        if (i > 0 && i < (k - 1))
                        {
                            grid[pozice].first = 2;
                        }
                        else
                        {
                            grid[pozice].first = 1;
                        }
                    }
                    // tmp == 1
                    if (!lode[lod = grid[pozice].second])
                    { // neprekryvala se
                        prekryteLode += 2;
                        prekrytaPole++;
                        lode[lod] = 1;
                        lode[pocetLodi] = 1;
                    }
                    else
                    { // prekryvala se
                        prekryteLode++;
                        prekrytaPole++;
                        lode[pocetLodi] = 1;
                    }
                }
                else
                { // prazdne pole
                    grid[pozice].first = 1;
                }
            }
            break;
        case 'D':
            for (int i = 0; i < k; i++)
            {
                pozice = start - i;
                if (tmp = grid[pozice].first)
                { // obsazeno
                    if (tmp > 1)
                    {
                        if (i > 0 && i < (k - 1))
                        {
                            // kryje se stred
                            cout << "No" << endl;
                            return 0;
                        }
                    }
                    else
                    { // oznaceni pole
                        if (i > 0 && i < (k - 1))
                        {
                            grid[pozice].first = 2;
                        }
                        else
                        {
                            grid[pozice].first = 1;
                        }
                    }
                    // tmp == 1
                    if (!lode[lod = grid[pozice].second])
                    { // neprekryvala se
                        prekryteLode += 2;
                        prekrytaPole++;
                        lode[lod] = 1;
                        lode[pocetLodi] = 1;
                    }
                    else
                    { // prekryvala se
                        prekryteLode++;
                        prekrytaPole++;
                        lode[pocetLodi] = 1;
                    }
                }
                else
                { // prazdne pole
                    grid[pozice].first = 1;
                }
            }
            break;
        default:
            break;
        }
    }

    cout << prekrytaPole << endl;
    cout << prekryteLode << endl;
    if (prekrytaPole < prekryteLode)
    {
        cout << "Yes" << endl;
    }
    else
    {
        cout << "No" << endl;
    }
    return 0;
}