#include <iostream>
#include <vector>
#include <cmath>
#include <queue>
#include <string>
#include <algorithm>
#include <fstream>
using namespace std;

ifstream fin;
ofstream fout;

struct par {
    long long s, f, x, y;
    par() {}
};

int mapSize = 25;
int maxMapX, minMapX, minMapY, maxMapY;
vector < par > pp;
long long n, p, k, h[256][256], startX, startY;
long long dx[4] = { 0, 1, 0, -1 }, dy[4] = { 1, 0, -1, 0 };
char dirS[4] = { 'D', 'R', 'U', 'L' };
vector < pair < long long , long long > > sl;
vector < long long > dist[16][256][256];
vector < char > dirInd[16][256][256];
long long closesSl[256][256][16];
priority_queue < pair < long long , pair < long long , long long > > > q;

vector < pair < long long , long long > > path;
vector < pair < long long , long long > > pathT;

void djSl ( long long slInd, long long cakesC ) {
    q.push( make_pair( 0, make_pair( sl[ slInd ].first, sl[ slInd ].second ) ) );
    for ( ; !q.empty() ; ) {
        long long cc = -q.top().first;
        pair < long long , long long > pos = q.top().second;
        q.pop();
        if ( dist[cakesC][ pos.first ][ pos.second ].size() == slInd ) {
            dist[cakesC][ pos.first ][ pos.second ].push_back( cc );
        }else {
            continue;
        }
        for ( long long i = 0 ; i < 4 ; i ++ ) {
            if ( pos.first + dy[i] < minMapY || pos.first + dy[i] >= maxMapY || pos.second + dx[i] < minMapX || pos.second + dx[i] >= maxMapX ) { continue; }
            int toX = pos.second + dx[i], toY = pos.first + dy[i];

            if ( dist[ cakesC ][ toY ][ toX ].size() > slInd ) { continue; }

            q.push(
                   make_pair ( -( cc + ( abs( h[ pos.first ][ pos.second ] - h[ pos.first+dy[i] ][ pos.second + dx[i] ] ) + (1<<cakesC)-1 )*
                              ( abs( h[ pos.first ][ pos.second ] - h[ pos.first+dy[i] ][ pos.second + dx[i] ] ) + (1<<cakesC)-1 ) ), make_pair( pos.first+dy[i], pos.second+ dx[i] ) ) );
        }
    }
}
void djSl2 ( long long slInd, long long cakesC ) {
    q.push( make_pair( 0, make_pair( sl[ slInd ].first, sl[ slInd ].second ) ) );
    for ( ; !q.empty() ; ) {
        long long cc = -q.top().first;
        pair < long long , long long > pos = q.top().second;
        q.pop();
        if ( dist[cakesC][ pos.first ][ pos.second ].size() == slInd ) {
            dist[cakesC][ pos.first ][ pos.second ].push_back( cc );
        }else {
            continue;
        }
        for ( long long i = 0 ; i < 4 ; i ++ ) {
            if ( pos.first + dy[i] < 0 || pos.first + dy[i] >= n || pos.second + dx[i] < 0 || pos.second + dx[i] >= n ) { continue; }
            int toX = pos.second + dx[i], toY = pos.first + dy[i];

            if ( dist[ cakesC ][ toY ][ toX ].size() > slInd ) { continue; }

            q.push(
                   make_pair ( -( cc + ( abs( h[ pos.first ][ pos.second ] - h[ pos.first+dy[i] ][ pos.second + dx[i] ] ) + (1<<cakesC)-1 )*
                              ( abs( h[ pos.first ][ pos.second ] - h[ pos.first+dy[i] ][ pos.second + dx[i] ] ) + (1<<cakesC)-1 ) ), make_pair( pos.first+dy[i], pos.second+ dx[i] ) ) );
        }
    }
}

int sol1() {
    for ( long long i = 0 ; i < n ; i ++ ) {
        for ( long long j = 0 ; j < n ; j ++ ) {
            fin >> h[i][j];
        }
    }
    fin >> startY >> startX;
    startX --; startY --;
    for ( long long i = 0 ; i < p ; i ++ ) {
        par crr;
        fin >> crr.y >> crr.x >> crr.s >> crr.f;
        crr.x --; crr.y --;
        crr.f += crr.s;
        pp.push_back( crr );
    }
    for ( long long i = 0 ; i < k ; i ++ ){
        pair < long long , long long > crr;
        fin >> crr.first >> crr.second;
        crr.first --; crr.second --;
        sl.push_back( crr );
    }

    for ( long long ccountSt = 0; ccountSt < 16 ; ccountSt ++ ) {
        for ( long long i = 0 ; i < sl.size() ; i ++ ) {
            djSl2( i, ccountSt );
        }
    }
    for ( long long cInd = 0 ; cInd < 16 ; cInd ++ ) {
        for ( long long i = 0 ; i < n ; i ++ ) {
            for ( long long j = 0 ; j < n ; j ++ ) {
                for ( long long k = 0 ; k < sl.size() ; k ++ ) {
                    if ( dist [ cInd][ i][j] [ closesSl[i][j][cInd] ] > dist[cInd][i][j][k] ) {
                        closesSl[i][j][cInd] = k;
                    }
                }
            }
        }
    }

     long long t = 0, crrX = startX, crrY = startY, ansVal = 0;
    for ( ; ; ) {
        long long maxSt = 0, maxInd = 0, maxVal = 0, maxTime = 1;
        //fout << t << "\n";
        for ( long long i = 0 ; i < pp.size() ; i ++ ) {
            for ( long long st = 0 ; st < 16 ; st ++ ) {
                long long slInd = closesSl[ pp[i].y ][ pp[i].x ][ st ];
                long long trTime = dist[ 0 ][ crrY ][ crrX ][ slInd ] + dist[ st ][ pp[i].y ][ pp[i].x ][ slInd ];
                if ( pp[i].f <= t + trTime ) { continue; }
                long long tVis = min( pp[i].f - t-trTime, pp[i].f-pp[i].s );
                if ( maxVal/(long double)maxTime < ( tVis*( (1<<st)-1+1 ) )/(long double)(pp[i].f+1) ) {
                    maxVal = tVis*( (1<<st)-1+1 );
                    maxSt = st;
                    maxInd = i;
                    maxTime = pp[i].f+1;
                }

            }
        }
        if ( maxVal == 0 ) { break; }


        long long slInd = closesSl[ pp[ maxInd ].y ][ pp[ maxInd ].x ][ maxSt ];
        long long trTime = dist[ 0 ][ crrY ][ crrX ][ slInd ] + dist[ maxSt ][ pp[ maxInd ].y ][ pp[ maxInd ].x ][ slInd ];
        //fout << "able to par " << pp[maxInd].s << " " << pp[maxInd].f << "  with " << ( (1<<maxSt)-1 ) << " for time " << trTime << "\n";

 //       path.push_back( make_pair ( sl[slInd], sl[slInd] ) );
        path.push_back( make_pair( slInd , 2 ) );
        pathT.push_back( make_pair( 1, maxSt ) );
        path.push_back( make_pair( pp[ maxInd ].y, pp[ maxInd ].x ) );
        pathT.push_back( make_pair( 2, maxSt ) );
        t = pp[maxInd].f +1;
        crrX = pp[maxInd].x;
        crrY = pp[maxInd].y;
        ansVal += maxVal;
    }

    crrX = startX;
    crrY = startY;
    int lastSl = -1;
    for ( int i = 0 ; i < path.size() ; i ++ ) {
        string crrPath;
        int tused = 0;
        if ( pathT[i].first == 1 ) { /// sl

            int cx = crrX, cy = crrY;
            for ( ; cx != sl[ path[i].first ].second || cy != sl[ path[i].first ].first ; ) {
                int minD = -1;
                for ( int kk = 0 ; kk < 4 ; kk ++ ) {
  //                  fout << i << " " << minD << "\n";
                    if ( cx + dx[kk] < 0 || cx + dx[kk] >= n || cy + dy[kk] < 0 || cy + dy[kk] >= n ) { continue;}
                    if ( minD == -1 ) { minD = kk; continue; }
//                    fout << "ok\n";

                  //  fout << pathT[i].second << " " << path[i].first << "\n";
                    if ( dist[ pathT[i].second ][ cy+dy[kk] ][ cx + dx[kk] ][ path[i].first ] < dist[ pathT[i].second ][ cy+dy[minD] ][ cx + dx[minD] ][ path[i].first ] ){
                        minD = kk;
                    }
                }
                //fout << "crr dir " << minD << "\n";
                if ( minD == -1 ) { break; }
                cx += dx[minD];
                cy += dy[minD];
                crrPath += dirS[ minD ];
            }
            lastSl = path[i].first;
            fout << crrPath << ( ( 1<<pathT[i].second ) -1 );
            crrX = cx;
            crrY = cy;
        }else {

            int cx = path[i].second, cy = path[i].first;
            for ( ; cx != sl[ lastSl ].second || cy != sl[ lastSl ].first ; ) {
                int minD = -1;
                for ( int kk = 0 ; kk < 4 ; kk ++ ) {
  //                  fout << i << " " << minD << "\n";
                    if ( cx + dx[kk] < 0 || cx + dx[kk] >= n || cy + dy[kk] < 0 || cy + dy[kk] >= n ) { continue;}
                    if ( minD == -1 ) { minD = kk; continue; }
//                    fout << "ok\n";

                  //  fout << pathT[i].second << " " << path[i].first << "\n";
                    if ( dist[ pathT[i].second ][ cy+dy[kk] ][ cx + dx[kk] ][ lastSl ] < dist[ pathT[i].second ][ cy+dy[minD] ][ cx + dx[minD] ][ lastSl ] ){
                        minD = kk;
                    }
                }
                //fout << "crr dir " << minD << "\n";
                if ( minD == -1 ) { break; }
                cx += dx[minD];
                cy += dy[minD];
                crrPath += dirS[ (2+minD)%4 ];
            }
            reverse ( crrPath.begin(), crrPath.end() );
            fout << crrPath << "+" << ( ( 1<<pathT[i].second ) -1 );
            crrX = path[i].second;
            crrY = path[i].first;
        }
    }
    fout << "\n";
    return 0;
}

int main () {
    fin.open( "party.in" );
    fout.open( "party.out" );
    fin >> n >> p >> k;
    if ( n*n*k*16 <= 10000000 ) { sol1() ; return 0; }
    for ( long long i = 0 ; i < n ; i ++ ) {
        for ( long long j = 0 ; j < n ; j ++ ) {
            fin >> h[i][j];
        }
    }
    fin >> startY >> startX;
    minMapX = max( 0LL, startX - mapSize );
    minMapY = max( 0LL, startY - mapSize );
    maxMapX = min( n, startX + mapSize );
    maxMapY = min( n, startY + mapSize );

    startX --; startY --;
    for ( long long i = 0 ; i < p ; i ++ ) {
        par crr;
        fin >> crr.y >> crr.x >> crr.s >> crr.f;
        crr.x --; crr.y --;
        crr.f += crr.s;
        if ( crr.x < minMapX || crr.x >= maxMapX || crr.y < minMapY || crr.y >= maxMapY ) { continue ;}
        pp.push_back( crr );
    }
    for ( long long i = 0 ; i < k ; i ++ ){
        pair < long long , long long > crr;
        fin >> crr.first >> crr.second;
        crr.first --; crr.second --;

        if ( crr.second < minMapX || crr.second >= maxMapX || crr.first < minMapY || crr.first >= maxMapY ) { continue ;}
        sl.push_back( crr );
    }

    for ( long long ccountSt = 0; ccountSt < 16 ; ccountSt ++ ) {
        for ( long long i = 0 ; i < sl.size() ; i ++ ) {
            djSl( i, ccountSt );
        }
    }
    for ( long long cInd = 0 ; cInd < 16 ; cInd ++ ) {
        for ( long long i = minMapY ; i < maxMapY ; i ++ ) {
            for ( long long j = minMapX ; j < maxMapX ; j ++ ) {
                for ( long long k = 0 ; k < sl.size() ; k ++ ) {
                    if ( dist [ cInd][ i][j] [ closesSl[i][j][cInd] ] > dist[cInd][i][j][k] ) {
                        closesSl[i][j][cInd] = k;
                    }
                }
            }
        }
    }
    long long t = 0, crrX = startX, crrY = startY, ansVal = 0;
    for ( ; ; ) {
        long long maxSt = 0, maxInd = 0, maxVal = 0, maxTime = 1;
        //fout << t << "\n";
        for ( long long i = 0 ; i < pp.size() ; i ++ ) {
            for ( long long st = 0 ; st < 16 ; st ++ ) {
                long long slInd = closesSl[ pp[i].y ][ pp[i].x ][ st ];
                long long trTime = dist[ 0 ][ crrY ][ crrX ][ slInd ] + dist[ st ][ pp[i].y ][ pp[i].x ][ slInd ];
                if ( pp[i].f <= t + trTime ) { continue; }
                long long tVis = min( pp[i].f - t-trTime, pp[i].f-pp[i].s );
                if ( maxVal/(long double)maxTime < ( tVis*( (1<<st)-1+1 ) )/(long double)(pp[i].f+1) ) {
                    maxVal = tVis*( (1<<st)-1+1 );
                    maxSt = st;
                    maxInd = i;
                    maxTime = pp[i].f+1;
                }

            }
        }
        if ( maxVal == 0 ) { break; }


        long long slInd = closesSl[ pp[ maxInd ].y ][ pp[ maxInd ].x ][ maxSt ];
        long long trTime = dist[ 0 ][ crrY ][ crrX ][ slInd ] + dist[ maxSt ][ pp[ maxInd ].y ][ pp[ maxInd ].x ][ slInd ];
        //fout << "able to par " << pp[maxInd].s << " " << pp[maxInd].f << "  with " << ( (1<<maxSt)-1 ) << " for time " << trTime << "\n";

 //       path.push_back( make_pair ( sl[slInd], sl[slInd] ) );
        path.push_back( make_pair( slInd , 2 ) );
        pathT.push_back( make_pair( 1, maxSt ) );
        path.push_back( make_pair( pp[ maxInd ].y, pp[ maxInd ].x ) );
        pathT.push_back( make_pair( 2, maxSt ) );
        t = pp[maxInd].f +1;
        crrX = pp[maxInd].x;
        crrY = pp[maxInd].y;
        ansVal += maxVal;
    }

    crrX = startX;
    crrY = startY;
    int lastSl = -1;
    for ( int i = 0 ; i < path.size() ; i ++ ) {
        string crrPath;
        int tused = 0;
        if ( pathT[i].first == 1 ) { /// sl

            int cx = crrX, cy = crrY;
            for ( ; cx != sl[ path[i].first ].second || cy != sl[ path[i].first ].first ; ) {
                int minD = -1;
                for ( int kk = 0 ; kk < 4 ; kk ++ ) {
  //                  fout << i << " " << minD << "\n";
                    if ( cx + dx[kk] < minMapX || cx + dx[kk] >= maxMapX || cy + dy[kk] < minMapY || cy + dy[kk] >= maxMapY ) { continue;}
                    if ( minD == -1 ) { minD = kk; continue; }
//                    fout << "ok\n";

                  //  fout << pathT[i].second << " " << path[i].first << "\n";
                    if ( dist[ pathT[i].second ][ cy+dy[kk] ][ cx + dx[kk] ][ path[i].first ] < dist[ pathT[i].second ][ cy+dy[minD] ][ cx + dx[minD] ][ path[i].first ] ){
                        minD = kk;
                    }
                }
                //fout << "crr dir " << minD << "\n";
                if ( minD == -1 ) { break; }
                cx += dx[minD];
                cy += dy[minD];
                crrPath += dirS[ minD ];
            }
            lastSl = path[i].first;
            fout << crrPath << ( ( 1<<pathT[i].second ) -1 );
            crrX = cx;
            crrY = cy;
        }else {

            int cx = path[i].second, cy = path[i].first;
            for ( ; cx != sl[ lastSl ].second || cy != sl[ lastSl ].first ; ) {
                int minD = -1;
                for ( int kk = 0 ; kk < 4 ; kk ++ ) {
  //                  fout << i << " " << minD << "\n";
                    if ( cx + dx[kk] < minMapX || cx + dx[kk] >= maxMapX || cy + dy[kk] < minMapY || cy + dy[kk] >= maxMapY ) { continue;}
                    if ( minD == -1 ) { minD = kk; continue; }
//                    fout << "ok\n";

                  //  fout << pathT[i].second << " " << path[i].first << "\n";
                    if ( dist[ pathT[i].second ][ cy+dy[kk] ][ cx + dx[kk] ][ lastSl ] < dist[ pathT[i].second ][ cy+dy[minD] ][ cx + dx[minD] ][ lastSl ] ){
                        minD = kk;
                    }
                }
                //fout << "crr dir " << minD << "\n";
                if ( minD == -1 ) { break; }
                cx += dx[minD];
                cy += dy[minD];
                crrPath += dirS[ (2+minD)%4 ];
            }
            reverse ( crrPath.begin(), crrPath.end() );
            fout << crrPath << "+" << ( ( 1<<pathT[i].second ) -1 );
            crrX = path[i].second;
            crrY = path[i].first;
        }
    }
    fout << "\n";
    return 0;
}
/*
16 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
16 16 0 16
16 16 500 150
16 16 1600 250
16 16 2000 150
16 16 3000 150
2 3 164 444
9 9
6 16
6 7

*/