#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <map>
#include <time.h>

using namespace std;
typedef long long Int;

struct party
{
    int x,y;
    int start;
    int ending;
};

const double TL=3.0;
const double TL2=4.9;

bool TimeIsOK()
{
    return (double)clock()/(double)CLOCKS_PER_SEC < TL;
}

bool TimeIsOK2()
{
    return (double)clock()/(double)CLOCKS_PER_SEC < TL2;
}

map< pair<int,int>,pair<int,int> > savedfact;
map< pair<int,int>,int > savedcake;

map< pair<int,int>,pair<int,int> >::iterator myit1;
map< pair<int,int>,int >::iterator myit2;

Int MIN(Int a,Int b)
{
    if (a<b)
    return a;
    else
    return b;
}

int MIN(int a,int b)
{
    if (a<b)
    return a;
    else
    return b;
}

int MAX(int a,int b)
{
    if (a>b)
    return a;
    else
    return b;
}

Int ABS(Int a)
{
    if (a<0)
    return -a;
    else
    return a;
}

Int Sq(Int a)
{
    return a*a;
}

int n,p,k;
int sX,sY;
party parties[100111];
Int grid[211][211];

char Path[100111];
int pL=0;

Int Sum;
Int SqSum;

Int GetSadPathPath(int x,int y,int gx,int gy,int cakes)
{
    if (x==gx && y==gy)
    return 0;

    if (x==gx)
    {
        if (y<gy)
        {
            pL++;
            Path[pL]='R';

            return ( Sq( ABS(grid[x][y]-grid[x][y+1])+cakes )+1 )+GetSadPathPath(x,y+1,gx,gy,cakes);
        }
        else
        {
            pL++;
            Path[pL]='L';

            return ( Sq( ABS(grid[x][y]-grid[x][y-1])+cakes )+1 )+GetSadPathPath(x,y-1,gx,gy,cakes);
        }
    }

    if (y==gy)
    {
        if (x<gx)
        {
            pL++;
            Path[pL]='D';

            return ( Sq( ABS(grid[x][y]-grid[x+1][y])+cakes )+1 )+GetSadPathPath(x+1,y,gx,gy,cakes);
        }
        else
        {
            pL++;
            Path[pL]='U';

            return ( Sq( ABS(grid[x][y]-grid[x-1][y])+cakes )+1 )+GetSadPathPath(x-1,y,gx,gy,cakes);
        }
    }

    char mv1,mv2;
    Int cost1,cost2;

    if (x<gx)
    {
        mv1='D';
        cost1=Sq( ABS(grid[x][y]-grid[x+1][y])+cakes )+1;
    }
    else
    {
        mv1='U';
        cost1=Sq( ABS(grid[x][y]-grid[x-1][y])+cakes )+1;
    }

    if (y<gy)
    {
        mv2='R';
        cost2=Sq( ABS(grid[x][y]-grid[x][y+1])+cakes )+1;
    }
    else
    {
        mv2='L';
        cost2=Sq( ABS(grid[x][y]-grid[x][y-1])+cakes )+1;
    }

    if (cost1<cost2)
    {
        pL++;
        Path[pL]=mv1;

        if (mv1=='D')
        {
            return cost1+GetSadPathPath(x+1,y,gx,gy,cakes);
        }
        else
        {
            return cost1+GetSadPathPath(x-1,y,gx,gy,cakes);
        }
    }
    else
    {
        pL++;
        Path[pL]=mv2;

        if (mv2=='R')
        {
            return cost2+GetSadPathPath(x,y+1,gx,gy,cakes);
        }
        else
        {
            return cost2+GetSadPathPath(x,y-1,gx,gy,cakes);
        }
    }
}

///

void GetSadPathVals(int x,int y,int gx,int gy)
{
    if (x==gx && y==gy)
    return;

    pL++;

    if (x==gx)
    {
        if (y<gy)
        {
            SqSum+=Sq(grid[x][y]-grid[x][y+1]);
            Sum+=ABS(grid[x][y]-grid[x][y+1]);

            GetSadPathVals(x,y+1,gx,gy);

            return;
        }
        else
        {
            SqSum+=Sq(grid[x][y]-grid[x][y-1]);
            Sum+=ABS(grid[x][y]-grid[x][y-1]);

            GetSadPathVals(x,y-1,gx,gy);

            return;
        }
    }

    if (y==gy)
    {
        if (x<gx)
        {
            SqSum+=Sq(grid[x][y]-grid[x+1][y]);
            Sum+=ABS(grid[x][y]-grid[x+1][y]);

            GetSadPathVals(x+1,y,gx,gy);

            return;
        }
        else
        {
            SqSum+=Sq(grid[x][y]-grid[x-1][y]);
            Sum+=ABS(grid[x][y]-grid[x-1][y]);

            GetSadPathVals(x-1,y,gx,gy);

            return;
        }
    }

    char mv1,mv2;
    Int cost1,cost2;

    if (x<gx)
    {
        mv1='D';
        cost1=Sq( grid[x][y]-grid[x+1][y] )+1;
    }
    else
    {
        mv1='U';
        cost1=Sq( grid[x][y]-grid[x-1][y] )+1;
    }

    if (y<gy)
    {
        mv2='R';
        cost2=Sq( grid[x][y]-grid[x][y+1] )+1;
    }
    else
    {
        mv2='L';
        cost2=Sq( grid[x][y]-grid[x][y-1] )+1;
    }

    if (cost1<cost2)
    {
        if (mv1=='D')
        {
            SqSum+=Sq(grid[x][y]-grid[x+1][y]);
            Sum+=ABS(grid[x][y]-grid[x+1][y]);

            GetSadPathVals(x+1,y,gx,gy);

            return;
        }
        else
        {
            SqSum+=Sq(grid[x][y]-grid[x-1][y]);
            Sum+=ABS(grid[x][y]-grid[x-1][y]);

            GetSadPathVals(x-1,y,gx,gy);

            return;
        }
    }
    else
    {
        if (mv2=='R')
        {
            SqSum+=Sq(grid[x][y]-grid[x][y+1]);
            Sum+=ABS(grid[x][y]-grid[x][y+1]);

            GetSadPathVals(x,y+1,gx,gy);

            return;
        }
        else
        {
            SqSum+=Sq(grid[x][y]-grid[x][y-1]);
            Sum+=ABS(grid[x][y]-grid[x][y-1]);

            GetSadPathVals(x,y-1,gx,gy);

            return;
        }
    }
}

////

int rowsum[211][211];
int hasfactory[211][211];

bool HasCakes(int x1,int y1,int x2,int y2)
{
    int i;

    if (x1<1)
    x1=1;
    if (y1<1)
    y1=1;
    if (x2>n)
    x2=n;
    if (y2>n)
    y2=n;

    for (i=x1;i<=x2;i++)
    {
        if (rowsum[i][y2]-rowsum[i][y1-1]>0)
        return true;
    }

    return false;
}

Int GetWin(int p1,int p2)
{
    int x1,y1;
    int x2,y2;
    int xTL,yTL,xBR,yBR;
    int l,r,mid,best;
    int i,j;
    int fX,fY;
    Int PreTime;
    Int HaveTime,BestTime;
    Int NoCakeAns,CakeAns;
    Int M;
    Int Val1,Val2;
    Int BestVal;
    int cakes;



    x1=parties[p1].x;
    y1=parties[p1].y;

    x2=parties[p2].x;
    y2=parties[p2].y;

    //cout<<x1<<";"<<y1<<" ~ "<<x2<<";"<<y2<<endl;

    xTL=MIN(x1,x2);
    yTL=MIN(y1,y2);

    xBR=MAX(x1,x2);
    yBR=MAX(y1,y2);

    l=0;
    r=n;

    while(l<=r)
    {
        mid=(l+r)/2;

        if (HasCakes(xTL-mid,yTL-mid,xBR+mid,yBR+mid))
        {
            best=mid;
            r=mid-1;
        }
        else
        {
            l=mid+1;
        }
    }

    xTL-=best;
    yTL-=best;
    xBR+=best;
    yBR+=best;

    //cout<<"Best is "<<best<<endl;

    fX=0;
    fY=0;

    for (i=yTL;i<=yBR;i++)
    {
        if (i<1 || i>n)
        continue;

        if (xTL>=1)
        {
            if (hasfactory[xTL][i]==1)
            {
                fX=xTL;
                fY=i;
                break;
            }
        }

        if (xBR<=n)
        {
            if (hasfactory[xBR][i]==1)
            {
                fX=xBR;
                fY=i;
                break;
            }
        }
    }

    for (i=xTL;i<=xBR;i++)
    {
        if (i<1 || i>n)
        continue;

        if (yTL>=1)
        {
            if (hasfactory[i][yTL]==1)
            {
                fX=i;
                fY=yTL;
                break;
            }
        }

        if (yBR<=n)
        {
            if (hasfactory[i][yBR]==1)
            {
                fX=i;
                fY=yBR;
                break;
            }
        }
    }

    if (fX==0 && fY==0)
    {
        for (i=xTL;i<=xBR;i++)
        {
            if (HasCakes(i,yTL,i,yBR))
            {
                for (j=yTL;j<=yBR;j++)
                {
                    if (i>=1 && i<=n && j>=1 && j<=n)
                    {
                        if (hasfactory[i][j]==1)
                        {
                            fX=i;
                            fY=j;
                            break;
                        }
                    }
                }

                if (fX!=0 || fY!=0)
                break;
            }
        }
    }

    //cout<<fX<<";"<<fY<<endl;

    savedfact.insert(make_pair(make_pair(p1,p2),make_pair(fX,fY)));

    ///Have the ~best factory coordinates

    HaveTime=(Int)parties[p2].ending-(Int)parties[p1].ending;
    BestTime=(Int)parties[p2].ending-(Int)parties[p2].start;

    //

    pL=0;
    PreTime=GetSadPathPath(x1,y1,x2,y2,0);

    if (HaveTime>PreTime)
    NoCakeAns=MIN( (HaveTime-PreTime),BestTime );
    else
    NoCakeAns=0;

    //cout<<"thus no cake ans win is "<<NoCakeAns<<endl;

    //

    pL=0;
    PreTime=GetSadPathPath(x1,y1,fX,fY,0);

    HaveTime-=PreTime;

    if (HaveTime<=0)
    return 0;

    pL=0;
    Sum=0;
    SqSum=0;
    GetSadPathVals(fX,fY,x2,y2);
    M=(Int)pL;

    //cout<<"We have "<<HaveTime<<" after first travel"<<endl;
    //cout<<"Best time is "<<BestTime<<endl;

    //cout<<"Almost"<<endl;

    l=1;
    r=100000;
    best=0;
    BestVal=0;

    while(l<=r)
    {
        mid=(l+r)/2;

        PreTime=SqSum+2LL*Sum*(Int)mid+M*(Int)mid*(Int)mid+M;
        if (HaveTime>PreTime)
        Val1=MIN( (HaveTime-PreTime),BestTime )*(Int)(mid);
        else
        Val1=0;

        PreTime=SqSum+2LL*Sum*(Int)(mid+1)+M*(Int)(mid+1)*(Int)(mid+1)+M;
        if (HaveTime>PreTime)
        Val2=MIN( (HaveTime-PreTime),BestTime )*(Int)(mid+1);
        else
        Val2=0;

        if (Val1>BestVal)
        {
            BestVal=Val1;
            best=mid;
        }

        if (Val2>BestVal)
        {
            BestVal=Val2;
            best=mid+1;
        }

        if (Val1<Val2)
        {
            l=mid+1;
        }
        else
        {
            r=mid-1;
        }
    }

    if (best==0)
    {
        savedcake.insert(make_pair(make_pair(p1,p2),0));
        return NoCakeAns;
    }

    PreTime=GetSadPathPath(fX,fY,x2,y2,best);
    if (HaveTime>PreTime)
    CakeAns=MIN( (HaveTime-PreTime),BestTime )*(Int)(best+1);
    else
    CakeAns=0;

    //cout<<"Pretime with 8 cakes is "<<PreTime<<endl;
    //cout<<"Thus we can party for "<<MIN( (HaveTime-PreTime),BestTime )<<endl;
    //cout<<"With "<<best<<" cakes we can achieve "<<CakeAns<<endl;

    if (CakeAns>NoCakeAns)
    {
        savedcake.insert(make_pair(make_pair(p1,p2),best));
        return CakeAns;
    }
    else
    {
        savedcake.insert(make_pair(make_pair(p1,p2),0));
        return NoCakeAns;
    }
}

bool SP(party A,party B)
{
    return A.ending<B.ending;
}

vector<int> CP;

char myoutput[100000111];
int L=0;

void PrintPath()
{
    int i;

    for (i=1;i<=pL;i++)
    {
        //printf("%c",Path[i]);
        L++;
        myoutput[L]=Path[i];
    }

    return;
}

void AddNum(Int K)
{
    char ch[11];
    int cL=0;

    while(K>0)
    {
        cL++;
        ch[cL]=(K%10)+'0';
        K/=10;
    }

    while(cL>0)
    {
        L++;
        myoutput[L]=ch[cL];
        cL--;
    }

    return;
}

void PErase(int ind)
{
    int i;

    for (i=ind;i<(int)CP.size()-1;i++)
    {
        CP[i]=CP[i+1];
    }
    CP.pop_back();

    return;
}

Int F[100111];
int LastChoice[100111];

int main()
{
    freopen("party.in","r",stdin);
    freopen("party.out","w",stdout);

    int i,j;
    int a,b;
    Int GetVal;
    Int Ans=0;
    int FX,FY,CAKES;
    int p1,p2;
    int l1,l2,l3;
    Int V1,V2,V3;
    int cur;
    int reach;

    scanf("%d %d %d",&n,&p,&k);

    for (i=1;i<=n;i++)
    {
        for (j=1;j<=n;j++)
        {
            scanf("%lld",&grid[i][j]);
        }
    }

    //cout<<"here?"<<endl;

    scanf("%d %d",&sX,&sY);

    for (i=1;i<=p;i++)
    {
        scanf("%d %d %d %d",&parties[i].x,&parties[i].y,&parties[i].start,&parties[i].ending);
        parties[i].ending+=parties[i].start;
    }

    for (i=1;i<=k;i++)
    {
        scanf("%d %d",&a,&b);

        hasfactory[a][b]=1;
    }

    for (i=1;i<=n;i++)
    {
        rowsum[i][0]=0;

        for (j=1;j<=n;j++)
        {
            rowsum[i][j]=rowsum[i][j-1]+hasfactory[i][j];
        }
    }

    p++;
    parties[p].x=sX;
    parties[p].y=sY;
    parties[p].start=-1;
    parties[p].ending=-1;

    sort(parties+1,parties+1+p,SP);

    //cout<<"here"<<endl;

    if ((Int)n*(Int)p*(Int)p<=20000000LL) ///Optimal dynamic programming assuming (falsely) optimality of the evaluation function (time limit allows use only in subgroup 1 or some other small tests)
    {
        F[1]=0;
        LastChoice[1]=0;

        reach=1;
        for (i=2;i<=p;i++)
        {
            if (!TimeIsOK())
            break;

            F[i]=-1;

            for (j=1;j<=i-1;j++)
            {
                if (F[j]==-1)
                continue;

                V1=GetWin(j,i);
                if (V1!=0)
                {
                    if (V1+F[j]>F[i])
                    {
                        F[i]=V1+F[j];
                        LastChoice[i]=j;
                    }
                }
            }

            reach=i;
        }

        Ans=0;
        cur=1;
        for (i=2;i<=p;i++)
        {
            if (F[i]>V1)
            {
                Ans=F[i];
                cur=i;
            }
        }

        while(cur!=0)
        {
            CP.push_back(cur);
            cur=LastChoice[cur];
        }

        reverse(CP.begin(),CP.end());
    }
    else
    {
        CP.push_back(1);

        for (i=2;i<=p;i++)
        {
            if (!TimeIsOK())
            break;
            //cout<<"At "<<i<<endl;

            GetVal=GetWin(CP.back(),i);

            //cout<<"Dead"<<endl;



            if (GetVal>0)
            {
                Ans+=GetVal;
                CP.push_back(i);
            }
        }

        cur=0;
        while(cur<CP.size()) ///Special convex-hull like optimization for all subgroups with appropriate time control (for larger subgroups it shouldnt have any effect
        {
            if (!TimeIsOK())
            break;

            if (cur<2)
            {
                cur++;
                continue;
            }

            l1=CP[cur-2];
            l2=CP[cur-1];
            l3=CP[cur];

            V1=GetWin(l1,l2);
            V2=GetWin(l2,l3);
            V3=GetWin(l1,l3);

            if (V1+V2 < V3)
            {
                Ans-=V1;
                Ans-=V2;
                Ans+=V3;

                PErase(cur-1);
                cur--;
            }
            else
            cur++;
        }
    }

    //cout<<"Nah"<<endl;

    for (i=0;i<(int)CP.size()-1;i++)
    {
        if (!TimeIsOK2())
        break;

        p1=CP[i];
        p2=CP[i+1];

        myit1=savedfact.find(make_pair(p1,p2));
        FX=(*myit1).second.first;
        FY=(*myit1).second.second;

        myit2=savedcake.find(make_pair(p1,p2));
        CAKES=(*myit2).second;

        if (CAKES==0)
        {
            pL=0;
            GetSadPathPath(parties[p1].x,parties[p1].y,parties[p2].x,parties[p2].y,0);

            PrintPath();
            L++;
            myoutput[L]='+';
            ///printf("+");
        }
        else
        {
            pL=0;
            GetSadPathPath(parties[p1].x,parties[p1].y,FX,FY,0);

            PrintPath();
            AddNum(CAKES);
            ///printf("%d",CAKES);

            pL=0;
            GetSadPathPath(FX,FY,parties[p2].x,parties[p2].y,CAKES);

            PrintPath();
            L++;
            myoutput[L]='+';
            AddNum(CAKES);
            ///printf("+%d",CAKES);
        }
    }
    //printf("\n");

    if (L==0)
    {
        L++;
        if (sX!=1)
        myoutput[L]='U';
        else
        myoutput[L]='D';
    }

    myoutput[L+1]=0;
    printf("%s\n",myoutput+1);

    //fprintf(stderr,"Expected %lld\n",Ans);

    //fprintf(stderr,"Time spent %d\n",total);

    return 0;