#include <bits/stdc++.h>
using namespace std;
using ll = long long;

/****************************************************
 * "Try a lot, keep only improvements" framework
 *  - N=10, T=1000, Ai < 2^20 固定前提。
 *  - 現在盤面boardと保持中sを持ち、いろんなヒューリスティックで候補sを作成。
 *  - 各候補ごとに実際の基底でdiffを構成→利得計算→ops/time内なら即採用。
 *  - 非劣化保証: gain<=0 なら採用しない。
 *
 *  Heuristics order (ループで繰り返し):
 *    1) 全体単一s 全探索 (最初の1回だけ)
 *    2) ブロックサイズ {5,4,3,2} 全探索 (全ブロック)
 *    3) ビットトグル利得最大 (1bitずつ)
 *    4) ランダムs候補 (RND_SAMPLES 回)
 *    5) ランダム小ブロック (RND_BLOCKS 回、サイズ2〜4)
 *  これらを時間/手数が切れるまで回す。
 *
 *  ルーティング: 必要セルのみを貪欲巡回。
 ****************************************************/

// ===== XOR Basis (20-bit) =====
struct XorBasis {
    static const int B = 20;
    int v[B];
    vector<int> mask[B];
    XorBasis(){ memset(v,0,sizeof(v)); }
    void add(int x, const vector<int>& cells){
        vector<int> c = cells;
        for(int b=B-1;b>=0;--b){
            if(((x>>b)&1)==0) continue;
            if(!v[b]){ v[b]=x; mask[b]=c; return; }
            x ^= v[b];
            vector<int> a = mask[b], res; res.reserve(c.size()+a.size());
            sort(c.begin(),c.end()); sort(a.begin(),a.end());
            size_t i=0,j=0;
            while(i<c.size()||j<a.size()){
                if(j==a.size() || (i<c.size() && c[i]<a[j])) res.push_back(c[i++]);
                else if(i==c.size() || a[j]<c[i]) res.push_back(a[j++]);
                else { ++i; ++j; }
            }
            c.swap(res);
        }
    }
    pair<int, vector<int>> build(int target) const{
        int t=target, made=0; vector<int> sel;
        for(int b=B-1;b>=0;--b){
            if(((t>>b)&1)==0) continue;
            if(!v[b]) continue;
            t ^= v[b]; made ^= v[b];
            vector<int> a = mask[b], res; res.reserve(sel.size()+a.size());
            sort(sel.begin(),sel.end()); sort(a.begin(),a.end());
            size_t i=0,j=0;
            while(i<sel.size()||j<a.size()){
                if(j==a.size() || (i<sel.size() && sel[i]<a[j])) res.push_back(sel[i++]);
                else if(i==sel.size() || a[j]<sel[i]) res.push_back(a[j++]);
                else { ++i; ++j; }
            }
            sel.swap(res);
        }
        return {made, sel};
    }
};

inline ll eval_score(const vector<int>& A, int s){
    ll sum=0; for(int x:A){ int y=x^s; sum += (y>x?y:x); } return sum; }

static void greedy_visit(int N,int &r,int &c,const vector<int>& ids,vector<char>& ops,char ch){
    if(ids.empty()) return;
    vector<char> used(ids.size(),0);
    for(size_t done=0; done<ids.size(); ++done){
        int best=-1, bestd=1e9;
        for(size_t i=0;i<ids.size();++i){
            if(used[i]) continue;
            int id=ids[i]; int rr=id/N, cc=id%N; int d=abs(rr-r)+abs(cc-c);
            if(d<bestd){ bestd=d; best=(int)i; }
        }
        used[best]=1; int id=ids[best]; int rr=id/N, cc=id%N;
        while(r<rr){ ops.push_back('D'); ++r; }
        while(r>rr){ ops.push_back('U'); --r; }
        while(c<cc){ ops.push_back('R'); ++c; }
        while(c>cc){ ops.push_back('L'); --c; }
        ops.push_back(ch);
    }
}

int main(){
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int N,T; if(!(cin>>N>>T)) return 0; // N=10, T=1000
    const int BITS=20, NN=100;

    vector<vector<int>> A(N,vector<int>(N));
    for(int i=0;i<N;i++) for(int j=0;j<N;j++) cin>>A[i][j];

    vector<int> board(NN); for(int i=0;i<N;i++) for(int j=0;j<N;j++) board[i*N+j]=A[i][j];
    vector<char> ops; ops.reserve(5000);
    int r=0,c=0; int curS=0;

    mt19937 rng(114514);

    auto start = chrono::steady_clock::now();
    const double TL = 1.90;
    auto time_ok=[&](){return chrono::duration<double>(chrono::steady_clock::now()-start).count()<TL;};

    auto total_sum=[&](){ ll s=0; for(int v:board) s+=v; return s; };

    // apply helper: try targetS, restrict W to idsRestrict (empty => all)
    auto try_apply = [&](int targetS, const vector<int>& idsRestrict, bool strict_restrict)->bool{
        if(!time_ok()) return false;
        ll base = total_sum();
        // Build basis on current board
        XorBasis B; for(int i=0;i<N;i++)for(int j=0;j<N;j++){int id=i*N+j; B.add(board[id], {id});}
        int diff = curS ^ targetS;
        auto [diffReal, needC] = B.build(diff);
        int newS = curS ^ diffReal;
        // decide W cells
        vector<int> wCells; wCells.reserve(NN);
        ll after=0;
        if(idsRestrict.empty()){
            for(int id=0; id<NN; ++id){ int a=board[id], b=a^newS; if(b>a){ wCells.push_back(id); after+=b; } else after+=a; }
        }else{
            vector<char> mark(NN,0); for(int id:idsRestrict) mark[id]=1;
            for(int id=0; id<NN; ++id){
                int a=board[id], b=a^newS;
                if(mark[id]){ // only update inside block
                    if(b>a){ wCells.push_back(id); after+=b; } else after+=a;
                }else{
                    // outside block: keep as is
                    after+=a;
                    if(!strict_restrict) {
                        // allow outside also if profitable (optional)
                        if(b>a){ wCells.push_back(id); after-=a; after+=b; }
                    }
                }
            }
        }
        ll gain = after - base;
        if(gain<=0) return false;
        // simulate ops
        vector<char> tmp; tmp.reserve(needC.size()*6 + wCells.size()*6 + 10);
        int tr=r, tc=c;
        greedy_visit(N,tr,tc,needC,tmp,'C');
        greedy_visit(N,tr,tc,wCells,tmp,'W');
        if((int)ops.size() + (int)tmp.size() > T) return false;
        // commit
        ops.insert(ops.end(), tmp.begin(), tmp.end());
        r=tr; c=tc; curS=newS;
        for(int id:wCells) board[id]^=curS;
        return true;
    };

    // ---- 0) global best single s (once) ----
    {
        ll base = total_sum();
        int bestS=0; ll bestG=0;
        for(int s=0;s<(1<<BITS);++s){
            ll tot=0; for(int x:board){ int y=x^s; tot+=(y>x?y:x);} ll g=tot-base; if(g>bestG){bestG=g; bestS=s;}
        }
        if(bestG>0) try_apply(bestS, {}, true);
    }

    // heuristic loop
    const int RND_SAMPLES = 2000;
    const int RND_BLOCKS  = 800;
    vector<int> blockSizes = {5,4,3,2};

    bool improved=true;
    while(improved && time_ok() && (int)ops.size() <= T-200){
        improved=false;

        // 1) block sizes deterministic scan
        for(int sz: blockSizes){
            if(!time_ok() || (int)ops.size()>T-200) break;
            for(int rs=0; rs<N; rs+=sz){
                int re=min(N,rs+sz);
                for(int cs=0; cs<N; cs+=sz){
                    int ce=min(N,cs+sz);
                    vector<int> ids; ids.reserve(sz*sz);
                    for(int i=rs;i<re;i++) for(int j=cs;j<ce;j++) ids.push_back(i*N+j);
                    // exhaust best s for this block
                    // compute current block sum
                    ll blkBase=0; for(int id:ids) blkBase+=board[id];
                    int bs=-1; ll bg=0;
                    for(int s=0;s<(1<<BITS);++s){
                        ll tot=0; for(int id:ids){ int a=board[id]; int b=a^s; tot+=(b>a?b:a);} ll g=tot-blkBase; if(g>bg){bg=g; bs=s;}
                    }
                    if(bg<=0) continue;
                    if(try_apply(bs, ids, true)) improved=true;
                }
            }
        }
        if(!time_ok() || (int)ops.size()>T-200) break;

        // 2) bit-greedy loop (one pass). Repeat outer while for more.
        for(int loop=0; loop<20 && time_ok() && (int)ops.size()<=T-200; ++loop){
            ll base=total_sum();
            // build basis once
            XorBasis B; for(int i=0;i<N;i++) for(int j=0;j<N;j++){ int idx=i*N+j; B.add(board[idx], {idx}); }
            int bestBit=-1; ll gainBest=0; int bestNewS=curS; vector<int> bestNeedC, bestW;
            for(int b=BITS-1;b>=0;b--){
                int diff = 1<<b;
                auto [diffReal, needC] = B.build(diff);
                int newS = curS ^ diffReal;
                ll g=0; vector<int> wCells;
                for(int id=0; id<NN; ++id){ int a=board[id], bval=a^newS; if(bval>a){ g+= (bval-a); wCells.push_back(id);} }
                if(g>gainBest || (g==gainBest && b>bestBit)){
                    gainBest=g; bestBit=b; bestNewS=newS; bestNeedC=needC; bestW=wCells;
                }
            }
            if(gainBest<=0) break;
            vector<char> tmp; tmp.reserve(bestNeedC.size()*6 + bestW.size()*6 + 10);
            int tr=r, tc=c;
            greedy_visit(N,tr,tc,bestNeedC,tmp,'C');
            greedy_visit(N,tr,tc,bestW,tmp,'W');
            if((int)ops.size()+ (int)tmp.size() > T) break;
            ops.insert(ops.end(), tmp.begin(), tmp.end());
            r=tr; c=tc; curS=bestNewS;
            for(int id:bestW) board[id]^=curS;
            improved=true;
        }
        if(!time_ok() || (int)ops.size()>T-200) break;

        // 3) random s full-board
        for(int k=0;k<RND_SAMPLES && time_ok() && (int)ops.size()<=T-200; ++k){
            int s = rng() & ((1<<BITS)-1);
            if(try_apply(s, {}, true)) improved=true;
        }
        if(!time_ok() || (int)ops.size()>T-200) break;

        // 4) random small blocks with random s subset (cheap approx)
        for(int k=0;k<RND_BLOCKS && time_ok() && (int)ops.size()<=T-200; ++k){
            int sz = 2 + (rng()%3); // 2..4
            int rs = rng()% (N-sz+1);
            int cs = rng()% (N-sz+1);
            vector<int> ids;
            for(int i=rs;i<rs+sz;i++) for(int j=cs;j<cs+sz;j++) ids.push_back(i*N+j);
            int s = rng() & ((1<<BITS)-1);
            if(try_apply(s, ids, true)) improved=true;
        }
    }

    if((int)ops.size()>T) ops.resize(T);
    for(char ch:ops) cout<<ch<<'\n';
    return 0;
}