#include <bits/stdc++.h>

using namespace std;

namespace {

    typedef long long ll;

    template<class T> ostream& operator<<(ostream& os, const vector<T>& vs) {
        if (vs.empty()) return os << "[]";
        os << "[" << vs[0];
        for (int i = 1; i < vs.size(); i++) os << " " << vs[i];
        return os << "]";
    }

    int H, W, N;
    int sx, sy, gx, gy;

    const int dy[] = {-1, 0, 1, 0};
    const int dx[] = {0, 1, 0, -1};

    const int MAX_H = 500 + 5;
    const int MAX_W = 500 + 5;
    
    ll F[MAX_H][MAX_W][4];

    bool check(int y, int x) {
        return 0 <= y && y < H && 0 <= x && x < W;
    }

    void input() {
        memset(F, 0, sizeof(F));
        cin >> W >> H >> N;
        cin >> sx >> sy >> gx >> gy;
        for (int i = 0; i < N; i++) {
            int x, y; cin >> x >> y;
            int T; cin >> T;
            string s; cin >> s;
            int cx = x, cy = y;
            for (int t = 0; t < T; t++) {
                for (int j = 0; j < s.size(); j++) {
                    char c = s[j];
                    int ny, nx;
                    switch (c) {
                        case 'U':
                            ny = cy - 1;
                            nx = cx;
                            if (check(ny, nx)) {
                                F[cy][cx][1]++;
                                F[cy][cx + 1][3]++;
                            }
                            break;
                        case 'L':
                            ny = cy;
                            nx = cx - 1;
                            if (check(ny, nx)) {
                                F[cy][cx][2]++;
                                F[cy + 1][cx][0]++;
                            }
                            break;
                        case 'D':
                            ny = cy + 1;
                            nx = cx;
                            if (check(ny, nx)) {
                                F[cy + 1][cx][1]++;
                                F[cy + 1][cx + 1][3]++;
                            }
                            break;
                        case 'R':
                            ny = cy;
                            nx = cx + 1;
                            if (check(ny, nx)) {
                                F[cy][cx + 1][2]++;
                                F[cy + 1][cx + 1][0]++;
                            }
                            break;
                        default: assert(false);
                    } 
                    if (check(ny, nx)) {
                        cy = ny;
                        cx = nx;
                    }
                }
            }
        }
    }

    const ll INF = 1LL<<58;

    struct State {
        int y, x;
        ll w;
        State(int y, int x, ll w) : y(y), x(x), w(w) {}
    };
    bool operator<(const State& a, const State& b) {
        return a.w > b.w;
    }

    void solve() {
        vector< vector<ll> > D(H + 1, vector<ll>(W + 1, INF));
        D[sy][sx] = 0;
        priority_queue<State> PQ;
        PQ.push(State(sy, sx, 0));
        while (!PQ.empty()) {
            State c = PQ.top(); PQ.pop();
            //cout << c.y << " " << c.x << " -> " << c.w << endl;
            for (int i = 0; i < 4; i++) {
                int ny = c.y + dy[i];
                int nx = c.x + dx[i];
                if (not (0 <= ny && ny <= H && 0 <= nx && nx <= W)) continue;
                ll nw = c.w + F[c.y][c.x][i];
                if (D[ny][nx] > nw) {
                    D[ny][nx] = nw;
                    PQ.push(State(ny, nx, nw));
                }
            }
        }
        cout << D[gy][gx] << endl;
        if (false) {
            cout << D << endl;
            for (int i = 0; i <= H; i++) {
                for (int j = 0; j <= W; j++) {
                    cout << "[";
                    for (int k = 0; k < 4; k++) {
                        cout << F[i][j][k] << " ";
                    }
                    cout << "] ";
                }
                cout << endl;
            }
        }
    }
}

int main() {
    input(); solve();
    return 0;
}

Measured memory_bytes: 16964