#include <stdio.h>
#include <cctype>
#include <limits.h>
#include <cmath>
#include <complex>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cstring>
#include <string>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>

#define VARIABLE(x) cerr << #x << "=" << x << endl
#define BINARY(x) static_cast<bitset<16> >(x)
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define if_range(x, y, w, h) if (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define is_in(x, y, w, h) (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
#define ALL(a) (a).begin(),(a).end()
int dx[4]={0, -1, 1, 0}, dy[4]={-1, 0, 0, 1};
using namespace std;
typedef long long ll;
typedef vector<vector<int> > VVI;
const int INF = 1e9;
typedef pair<int, int> PII;

const int MAX_V = 510 * 510;

const string move_label = "ULRD";
int W, H;

struct edge{
	int to, cost;
	edge(int t, int c=0):to(t), cost(c){}
};
vector<edge> G[MAX_V];
int d[MAX_V];

bool used[MAX_V];
int V;

void dijkstra(int s)
{
	priority_queue<PII, vector<PII>, greater<PII> > Q;
	fill(d, d+V, INF);
	d[s] = 0;
	Q.push(PII(0, s));
	
	while (Q.size()) {
		PII p = Q.top(); Q.pop();
		int v = p.second;
		if (d[v] < p.first) continue;
		for (int i=0; i<G[v].size(); i++) {
			edge e = G[v][i];
			if (d[e.to] > d[v] + e.cost) {
				d[e.to] = d[v] + e.cost;
				Q.push(PII(d[e.to], e.to));
			}
		}
	}
}


int get_idx(int x, int y)
{
	return x + y*W;
}


int main()
{
	int N;
	cin >> W >> H >> N;
	W++, H++;
	V = W*H;
	
	int sx, sy, gx, gy;
	cin >> sx >> sy >> gx >> gy;
	
	for (int x=0; x<W; x++) {
		for (int y=0; y<H; y++) {
			for (int i=0; i<4; i++) {
				int nx = x + dx[i], ny = y + dy[i];
				if_range(nx, ny, W, H) {
					int u = get_idx(x, y), v = get_idx(nx, ny);
					G[u].push_back(v);
					// G[v].push_back(u);
				}
			}
		}
	}
	
	for (int i=0; i<N; i++) {
		int x, y, T;
		string S;
		
		cin>>x>>y>>T>>S;
		
		for (int t=0; t<T; t++) {
			for (int j=0; j<S.size(); j++) {
				// cerr << "(" << x << ", " << y << ")" << endl;
				
				int idx = (int)move_label.find(S[j], 0);
				int nx = x+dx[idx], ny = y+dy[idx];
				
				if (!is_in(nx, ny, W-1, H-1)) continue;
				
				int u=-1, v=-1;
				switch (S[j]) {
					case 'R':
						if (is_in(x+1, y, W, H) && is_in(x+1, y+1, W, H)) {
							u = get_idx(x+1, y), v = get_idx(x+1, y+1);
						}
						break;
						
					case 'L':
						if (is_in(x, y, W, H) && is_in(x, y+1, W, H)) {
							u = get_idx(x, y), v = get_idx(x, y+1);
						}
						break;
						
					case 'U':
						if (is_in(x, y, W, H) && is_in(x+1, y, W, H)) {
							u = get_idx(x, y), v = get_idx(x+1, y);
						}
						break;
						
					case 'D':
						if (is_in(x, y+1, W, H) && is_in(x+1, y+1, W, H)) {
							u = get_idx(x, y+1), v = get_idx(x+1, y+1);
						}
						break;
				}
				// cerr << "u = " << u << ", v = " << v << endl;
				
				if (u>=0 && v>=0) {
					for (auto &g : G[u]) if (g.to == v) g.cost++;
					for (auto &g : G[v]) if (g.to == u) g.cost++;
				
					int idx = (int)move_label.find(S[j], 0);
					x += dx[idx], y += dy[idx];
				}
			}
		}
	}
	
	dijkstra(get_idx(sx, sy));
	cout << d[get_idx(gx, gy)] << endl;
}

Measured memory_bytes: 21976