//
#include<iostream>
#include<cmath>
#include<iomanip>
#include<algorithm>
#include<cstring>
#include<string>
#include<queue>
#include<vector>
#include<climits>
#include<fstream>
#include<map>
#define lli long long
#define mp make_pair
using namespace std;

struct Party
{
    int x,y,Begin, End;
};

string Answer;
pair<int,int> P1;
queue< pair<int,int> > q;
vector< pair<int,int> >Cake;
char dp1[202][202];
int a[220][220],dp[201][201],n,p,m,r,Fx,Fy;
bool b[220][220],used[201][201];
Party P[200000];

bool Cmp(Party A, Party B)
{
    if(A.x==B.x && A.y==B.y)return A.Begin<B.Begin;
    if(A.End-A.Begin!=B.End-B.Begin)return A.End-A.Begin>B.End-B.Begin;
    else return A.Begin>B.Begin;
}



int FindMin(int X,int Y,int X1,int Y1)
{
    memset(dp,0,sizeof(dp));
    memset(dp1,0,sizeof(dp1));

    bool l=0;
    if(X>X1){swap(X,X1); swap(Y,Y1);l=1;}
    for(int i=X;i<=X1;i++)
    {
        for(int j=Y;j<=Y1;j++)
        {
            if(i==X && j==Y)continue;

            if(i!=X)
            {
                dp[i][j]=dp[i-1][j]+(abs(a[i][j]-a[i-1][j])*abs(a[i][j]-a[i-1][j]));
                //if(l)dp1[i][j]='U';
                dp1[i][j]='U';
            }
            else dp[i][j]=INT_MAX;

            if(j!=Y && dp[i][j]>dp[i][j-1]+abs(a[i][j]-a[i][j-1])*abs(a[i][j]-a[i][j-1]))
            {
                dp[i][j]=dp[i][j-1]+abs(a[i][j]-a[i][j-1])*abs(a[i][j]-a[i][j-1]);
                //if(l)dp1[i][j]='L';
                dp1[i][j]='L';
            }
            dp[i][j]++;
        }

        for(int j=Y;j>=Y1;j--)
        {
            if(i!=X)
            {
                dp[i][j]=dp[i-1][j]+abs(a[i][j]-a[i-1][j])*abs(a[i][j]-a[i-1][j]);
                //if(l)dp1[i][j]='U';
                dp1[i][j]='U';
            }
            else dp[i][j]=INT_MAX;

            if(j!=Y && dp[i][j]>dp[i][j+1]+abs(a[i][j]-a[i][j+1])*abs(a[i][j]-a[i][j+1]))
            {
                dp[i][j]=dp[i][j+1]+abs(a[i][j]-a[i][j+1])*abs(a[i][j]-a[i][j+1]);
                dp1[i][j]='R';
                //if(l)dp1[i][j]='R';

            }
            dp[i][j]++;
        }

    }
    return dp[X1][Y1];
}

string Ans;
int PrintIt(int X,int Y,int X1,int Y1)
{
    Ans.clear();
    bool l=0;
    if(X>X1){swap(X,X1); swap(Y,Y1);l=1;}
    int k=X1,k1=Y1;
    while(k!=X || k1!=Y)
    {
        //cout<<X1<<" "<<Y1<<"\n";
        //cout<<X<<" "<<Y<<"\n";
        //cout<<k<<" "<<k1<<"\n";
        Ans.push_back(dp1[k][k1]);
        if(dp1[k][k1]=='R')k1++;
        else if(dp1[k][k1]=='L')k1--;
        else if(dp1[k][k1]=='U')k--;
        else if(dp1[k][k1]=='D')k++;
    }

    //cout<<l<<"\n";
    if(!l)
    {
        for(int i=0;i<Ans.size();i++)
        {
            if(Ans[i]=='R')Ans[i]='L';
            else if(Ans[i]=='L')Ans[i]='R';
            else if(Ans[i]=='U')Ans[i]='D';
            else if(Ans[i]=='D')Ans[i]='U';

        }
    }

    for(int i=0;i<Ans.size()/2;i++)
    {
        swap(Ans[i],Ans[Ans.size()-i-1]);
    }
    Answer=Answer+Ans;
    //cout<<Ans;



}


void solve()
{
    int X=Fx,Y=Fy,T,TimeNow=0,T1,Delta,BrCakes,D1,Score=0,L,R;
    for(int t1=1;t1<=p;t1++)
    {
        if(TimeNow>P[t1].End)continue;

        T=P[t1].End;
        T1=FindMin(X,Y,P[t1].x,P[t1].y);
        if(T1+TimeNow>T)continue;

        L=T1+TimeNow;
        if(T1+TimeNow<P[t1].Begin)L=P[t1].Begin;
        PrintIt(X,Y,P[t1].x,P[t1].y);
        Answer.push_back('+');
        TimeNow=P[t1].End;
        X=P[t1].x; Y=P[t1].y;


        //T-=T1;

        /*for(int j=1;j<=m;j++)
        {



            if(T<T1)continue;

            /*
            T1=FindMin(X,Y,Cake[j].first, Cake[j].second);
            T-=T1;

            Delta=FindMin(P[t1].x,P[t1].y,Cake[j].first, Cake[j].second);
            D1=Delta*Delta-2*Delta+1+3*T;

            BrCakes= (-2*Delta-1+sqrt(D1))/3;
            Score=abs(T-(BrCakes+Delta));
        }
        */
    }

}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    ifstream cin("party.in");
    ofstream cout("party.out");

    int Help,Help1;
    cin>>n>>p>>m;

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cin>>a[i][j];
        }
    }

    cin>>Fx>>Fy;

    for(int i=1;i<=p;i++)
    {
        cin>>P[i].x>>P[i].y>>P[i].Begin>>P[i].End;
        P[i].End+=P[i].Begin;
    }

    for(int i=1;i<=m;i++)
    {
        cin>>Help>>Help1;

        b[Help][Help1]=1;
        Cake.push_back(mp(Help,Help1));
    }
    sort(P+1,P+p+1,Cmp);


    solve();
    cout<<Answer<<"\n";
    return 0;
}
/*
10 8 3
1 2 3 2 1 2 3 4 5 6
9 8 7 6 5 4 3 2 1 0
5 5 5 5 5 5 5 5 5 5
4 3 2 1 0 1 2 3 4 5
9 9 9 8 8 8 2 7 7 6
9 9 9 6 6 5 5 4 4 3
9 8 7 3 2 2 2 1 1 1
6 5 4 0 0 0 1 2 3 4
0 0 0 5 6 7 8 9 8 7
0 0 0 6 5 4 3 2 1 0
6 6
5 5 3 2
7 1 2 2
10 10 0 12
10 10 500 150
10 10 1000 250
10 10 2000 150
10 10 3000 150
2 3 124 444
9 9
6 10
6 7

*/
/*

5 4 3
0 3 2 1 2
3 4 2 6 3
99 5 3 3 3
8 5 2 6 5
5 1 11 5 8
2 2
3 1 999 999
5 5 120 20
5 4 42 69
1 5 7 2
3 4
2 5
4 4
*/