//#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <set>
#include <stack>
using namespace std;

const int MAXN = 205;
const int MAXP = 100005;
const int INF = 1<<30;

ifstream cin("party.in");
ofstream cout("party.out");

int consts[4][2]={{4, 400}, {3, 400}, {2, 400}, {1, 400}};

int FC, SC;

struct Party
{
    int x, y, t, w;
    Party(int x, int y, int t, int w)
    {
        this->x=x;
        this->y=y;
        this->t=t;
        this->w=w;
    }
};

int n, p, k;

int a[MAXN][MAXN];

int dist[MAXN][MAXN];
pair<int, int> pred[MAXN][MAXN];

vector<pair<int, int> > s;
vector<Party> party;

int sys_time=0;
long long cur_time=0;

int homx, homy;
int nop=0, last;

int dir[4][2] = {{-1, 0}, {+1, 0}, {0, +1}, {0, -1}};
int bor[4][4];

bool cmp(Party p1, Party p2)
{
    return p1.t+p1.w<p2.t+p2.w;
}

void Border()
{
    bor[0][0]=1; bor[0][1]=n+1; bor[0][2]=0; bor[0][3]=n+1;
    bor[1][0]=0; bor[1][1]=n; bor[1][2]=0; bor[1][3]=n+1;
    bor[2][0]=0; bor[2][1]=n+1; bor[2][2]=0; bor[2][3]=n;
    bor[3][0]=0; bor[3][1]=n+1; bor[3][2]=1; bor[3][3]=n+1;
}

void Init()
{
    cin>>n>>p>>k;

    Border();

    for (int i=1; i<=n; i++)
    {
        for (int j=1; j<=n; j++)
        {
            cin>>a[i][j];
        }
    }
    cin>>homx>>homy;
    for (int i=1; i<=p; i++)
    {
        int x, y, t, w;
        cin>>x>>y>>t>>w;
        party.push_back(Party(x, y, t, w));
    }
    for (int i=1; i<=k; i++)
    {
        int x, y;
        cin>>x>>y;
        s.push_back(make_pair(x, y));
    }

    stable_sort(party.begin(), party.end(), cmp);
    last=party[party.size()].t+party[party.size()].w;
}

void calcDist(int x, int y, int cakes)
{
    for (int i=1; i<=n; i++)
    {
        for (int j=1; j<=n; j++)
        {
            dist[i][j]=INF;
        }
    }

    set<pair<int, pair<int, int> > > q;
    q.insert(make_pair(0, make_pair(x, y)));

    dist[x][y]=0;
    pred[x][y]=make_pair(0, 0);

    while (!q.empty())
    {
        pair<int, pair<int, int> > e=*q.begin();
        q.erase(q.begin());

        int t = e.first;
        int px = e.second.first;
        int py = e.second.second;

        for (int pos=0; pos<4; pos++)
        {
            if (px>bor[pos][0] and px<bor[pos][1] and py>bor[pos][2] and py<bor[pos][3])
            {
                int nx = px+dir[pos][0];
                int ny = py+dir[pos][1];

                int dif=abs(a[px][py] - a[nx][ny]);
                if (dist[nx][ny]>dist[px][py]+(dif+cakes)*(dif+cakes)+1)
                {
                    dist[nx][ny] = dist[px][py]+(dif+cakes)*(dif+cakes)+1;
                    pred[nx][ny] = make_pair(px, py);
                    q.insert(make_pair(dist[nx][ny], make_pair(nx, ny)));
                }
            }
        }
    }
}

void nextStore(int * curx, int * cury, int * cakes)
{
    calcDist(*curx, *cury, *cakes);

    int mint=INF;
    int minx, miny;
    for (int i=0; i<k; i++)
    {
        int storeX=s[i].first;
        int storeY=s[i].second;

        if (dist[storeX][storeY]<mint)
        {
            mint=dist[storeX][storeY];
            minx=storeX;
            miny=storeY;
        }
    }
    cur_time+=mint;

    stack<char> st;

    int tx=minx;
    int ty=miny;
    while (true)
    {
        int nx=pred[tx][ty].first;
        int ny=pred[tx][ty].second;

        if (nx==0 or ny==0) break;

        if (nx+1==tx) st.push('D');
        if (nx-1==tx) st.push('U');
        if (ny+1==ty) st.push('R');
        if (ny-1==ty) st.push('L');

        tx=nx; ty=ny;
    }

    while (!st.empty())
    {
        cout<<st.top();
        st.pop();
    }
    *curx=minx; *cury=miny; *cakes=n/FC; //change in main function

    if (*cakes!=0) cout<<*cakes;
}

void nextParty(int * curx, int * cury, int * cakes)
{
    calcDist(*curx, *cury, *cakes);

    while (nop<p)
    {
        Party e = party[nop];
        if (e.t + e.w > cur_time + dist[e.x][e.y])
        {
            cur_time = e.t+e.w;
            int tx = e.x;
            int ty = e.y;

            stack<char> st;
            while (true)
            {
                int nx = pred[tx][ty].first;
                int ny = pred[tx][ty].second;

                if (nx==0 or ny==0) break;

                if (nx+1==tx) st.push('D');
                if (nx-1==tx) st.push('U');
                if (ny+1==ty) st.push('R');
                if (ny-1==ty) st.push('L');

                tx=nx; ty=ny;
            }

            while (!st.empty())
            {
                cout<<st.top();
                st.pop();
            }
            cout<<'+';
            if (*cakes!=0) cout<<*cakes;

            *curx=e.x; *cury=e.y; *cakes=0; //change in main function

            nop++;
            return;
        }
        nop++;
    }
}

int main()
{
    sys_time=clock();
    srand(time(0));

    Init();

    if (n<=10) {FC=consts[0][0]; SC=consts[0][1];}
    if (n<=20) {FC=consts[1][0]; SC=consts[1][1];}
    if (n<=100) {FC=consts[2][0]; SC=consts[2][1];}
    if (n<=200) {FC=consts[3][0]; SC=consts[3][1];}

    int x=homx;
    int y=homy;

    int cakes=0;
    int prevStep=0;

    while (nop!=p and clock()-sys_time<4800 and cur_time<9000000000)
    {
        if (rand()%(SC/n)!=0)
        {
            nextParty(&x, &y, &cakes);
            prevStep = 1;
        }
        else if (prevStep!=2)
        {
            nextStore(&x, &y, &cakes);
            prevStep = 2;
        }
    }

    cout<<endl;
    return 0;
}