// Template {{{
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
using namespace std;
typedef long long LL;

#ifdef LOCAL
#include "contest.h"
#else
#define dump(x) 
#endif

class range {
    struct Iterator {
        int val, inc;
        int operator*() {return val;}
        bool operator!=(Iterator& rhs) {return val < rhs.val;}
        void operator++() {val += inc;}
    };
    Iterator i, n;
    public:
    range(int e) : i({0, 1}), n({e, 1}) {}
    range(int b, int e) : i({b, 1}), n({e, 1}) {}
    range(int b, int e, int inc) : i({b, inc}), n({e, inc}) {}
    Iterator& begin() {return i;}
    Iterator& end() {return n;}
};

inline bool valid(int x, int w) { return 0 <= x && x < w; }

void iostream_init() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.setf(ios::fixed);
    cout.precision(12);
}
//}}}
//
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
// R D L U

int main(){
    iostream_init();
    int W, H, N;
    while(cin >> W >> H >> N) {
        int sx, sy, gx, gy;
        cin >> sx >> sy >> gx >> gy;

        int cost[505][505][4] = {};
        map<char, int> get_r;
        get_r['R'] = 0;
        get_r['D'] = 1;
        get_r['L'] = 2;
        get_r['U'] = 3;
        REP(i, N) {
            int cx, cy;
            cin >> cx >> cy;
            int T;
            cin >> T;
            string s;
            cin >> s;
            REP(_, T) {
                for(char c : s) {
                    int r = get_r[c];
                    int nx = cx + dx[r];
                    int ny = cy + dy[r];
                    if(!valid(nx, W)) continue;
                    if(!valid(ny, H)) continue;
                    if(r == 0) {
                        // R
                        cost[cy][nx][1] ++;
                        cost[cy+1][nx][3] ++;
                    } else if(r == 1) {
                        // D
                        cost[ny][cx][0]++;
                        cost[ny][cx+1][2]++;
                    } else if(r == 2) {
                        // L 
                        cost[cy][cx][1] ++;
                        cost[cy+1][cx][3] ++;
                    } else if(r == 3) {
                        // U
                        cost[cy][cx][0]++;
                        cost[cy][cx+1][2]++;
                    }
                    cx = nx;
                    cy = ny;
                }
            }
        }

        typedef tuple<int, int, int> T;
        priority_queue<T, vector<T>, greater<T>> que;
        int dist[505][505] = {};
        const int INF = 1e9;
        REP(y, H+1) REP(x, W+1) dist[y][x] = INF;

        dist[sy][sx] = 0;
        que.push(T(0, sx, sy));
        while(!que.empty()) {
            int d, x, y;
            tie(d, x, y) = que.top(); que.pop();
            REP(r, 4) {
                int nx = x + dx[r];
                int ny = y + dy[r];
                if(!valid(nx, W+1)) continue;
                if(!valid(ny, H+1)) continue;
                int nd = d + cost[y][x][r];
                if(dist[ny][nx] > nd) {
                    dist[ny][nx] = nd;
                    que.push(T(nd, nx, ny));
                }
            }
        }
        cout << dist[gy][gx] << endl;
    }
    return 0;
}

/* vim:set foldmethod=marker: */