#include<bits/stdc++.h>

using namespace std;

const int maxN = 2e4+10;

#define pb push_back

const long long b1 = 61;
const long long b2 = 37;
const long long mo1 = 1e9+7;
const long long mo2 = 1e9 + 9;

const double iterConst1 = 3.4;
const double iterConst2 = 3.5 ;
const double iterConst3 = 0.0;
const int square = 8;

vector<char> res[maxN], curRes[maxN];
string word[maxN];
int bestAns = 1e6;
int bestX, bestY, curX, curY;
vector<pair<pair<int,int>, string>> moves, curMoves;
int subtask, n;
int startX, startY;
mt19937 rng(time(0));
pair<string, int> sortedWords[maxN];
vector<pair<int, int>> previousMoves;
clock_t startTime;
int dist[100][100][100];
pair<int,int> pre[100][100][100];
int sumLen = 0;
int badMode[maxN];
int solve2Res;
int lastRow;

void read_data()
{
    freopen("crossword.in", "r", stdin);

    cin>>subtask;

    cin>>n;

    sumLen = 0;
    for (int i=0; i<n; i++)
    {
        cin>>word[i];
        sumLen +=word[i].size();
    }

    fclose(stdin);
}


int initializer()
{
    for (int i=0; i<n; i++)
        sortedWords[i] = {word[i], i};

    sort(sortedWords, sortedWords + n);

    curX = 5000;
    curY = 200;
}

void print_data()
{
    freopen("crossword.out", "w",stdout);

    cout<<bestY<<" "<<bestX<<endl;

    for (int i=0; i<bestX; i++)
    {
        string ans = "";
        for (int j=0; j<bestY; j++)
            ans+=res[i][j];
        cout<<ans<<endl;
    }

    for (auto i:moves)
        cout<<i.first.second<<" "<<i.first.first<<" "<<i.second<<endl;

    fclose(stdout);
}

int inside(int x, int y)
{
    return (x>=0 && x<curX && y>=0 && y<curY);
}

int ok(int x, int y)
{
    return (inside(x, y) && !curRes[x][y]);
}

double calcTime()
{
    double val = ((double) clock() - startTime)/(CLOCKS_PER_SEC);
    return val;
}

void make(int curX, int curY)
{
    for (int i=0; i<curX; i++)
    {
        curRes[i].clear();
        curRes[i].resize(curY);
    }

    curMoves.clear();

    curMoves.resize(n);
}

void replaceBest()
{
    bestX = curX;
    bestY = curY;
    int score = 0;

    for (int i = 0; i< curX; i++)
    {
        res[i].resize(curY, 0);

        for (int j = 0; j<curY; j++)
        {
            if (curRes[i][j])
                score++;
            if (!curRes[i][j])
                curRes[i][j] = '#';
            res[i][j] = curRes[i][j];
        }
    }

    moves.assign(curMoves.begin(), curMoves.end());

    bestAns = score;
}

int calcScore()
{
    int score = 0;
    for (int i = 0; i < curX; i++)
        for (int j=0; j<curY; j++)
            if (curRes[i][j])
                score++;

    return score;
}

char from_to(int x, int y)
{
    if (y>0)
        return 'R';
    if (y<0)
        return 'L';
    if (x>0)
        return 'D';
    return 'U';
}

int finder(int x, int y, string &s, int idx)
{
    if (idx == s.size() - 1)
        return idx + 1;

    if (inside(x, y + 1) && curRes[x][y + 1] == s[idx + 1])
        return finder(x, y+1, s, idx+1);

    if (inside(x, y-1) && curRes[x][y-1] == s[idx + 1])
        return finder(x, y-1, s, idx+1);

    return idx + 1 ;
}

int pref(string &s, string &t)
{
    int sz1 = s.size();
    int sz2 = t.size();
    long long hs11 = 0;
    long long hs12 = 0;
    long long hs21 = 0;
    long long hs22 = 0;

    long long curb1 = 1;
    long long curb2 = 1;

    int ans = 0;

    for (int i=0; i<min(curY/2, min(sz1, sz2)); i++)
    {
        curb1 = (curb1*b1)%mo1;
       // curb2 = (curb2 * b2)%mo2;
        hs11 = (hs11 + curb1 * (t[i] - 'a'))%mo1;
       // hs12 = (hs12 + curb2 * (t[i] - 'a'))%mo2;

        hs21 = ((hs21 + (s[sz1 - i -1] - 'a'))*b1)%mo1;
       // hs22 = ((hs22 + (s[sz1 - i -1] - 'a'))*b2)%mo2;

        if (hs11 == hs21)
            ans = i + 1;
    }

    return ans;
}


void custom_sort()
{
    string bez[20];
    for (int i = 0 ; i <n-1; i++)
    {
        int best = pref(sortedWords[i].first, sortedWords[i+1].first);

        int sz = sortedWords[i].first.size();

        for (int j=0; j<min(5, sz-1); j++)
            bez[j] = sortedWords[i].first.substr(0, sz- j);

        for (int j= i+2; j< (i+70, n); j++)
        {
            for (int k = 0; k<= min(5, sz-1); k++)
            {
                int len = pref(bez[k], sortedWords[j].first);
                if ( best < len)
                {
                    swap(sortedWords[i+1], sortedWords[j]);
                    best = len;
                    break;
                }
            }
        }
    }
}


void coverFrom(int x, int y, string &s, int idx, int strId, int step)
{
    curRes[x][y] = s[idx];

    int dx[3] = {0, 0,  step};
    int dy[3] = {1, -1, 0};

    if (idx == s.size() - 1)
    {
        startX = x;
        lastRow = x;
        return;
    }
    for (int i = 0; i<2; i++)
        if (inside(x + dx[i], y + dy[i]) && idx<s.size()-1 && s[idx + 1] == curRes[x + dx[i]][y + dy[i]])
        {
            curMoves[strId].second += from_to(dx[i], dy[i]);
            previousMoves.pb({x+dx[i], y+dy[i]});
            coverFrom(x + dx[i], y + dy[i], s, idx+1, strId, step);
            return;
        }

    for (int i=0; i<3; i++)
        if (ok(x + dx[i], y + dy[i]))
        {
            curMoves[strId].second += from_to(dx[i], dy[i]);
            previousMoves.pb({x+dx[i], y+dy[i]});
            coverFrom(x+dx[i], y + dy[i], s, idx+1, strId, step);
            return;
        }
    return;
}



void solve1()
{

    while(calcTime() < iterConst1)
    {

        startX = 0 ;
        startY = 50;
        custom_sort();

        make(curX, curY);
        previousMoves.clear();

        for (int i=0; i<n; i++)
        {
            int found = 0;

            while(!found)
            {
                for (int j = 0; j < curY; j++)
                    if (!curRes[startX][j] && !curRes[startX + 1][j])
                    {
                        startY = j;
                        found = 1;
                        break;
                    }
                if (!found)
                    startX++;
            }

            int pozX  = startX;
            int pozY = startY;
            int reversedMode = 0;

            if (i==0)
            {
                previousMoves.pb({pozX, pozY});
                curMoves[sortedWords[i].second] = {{pozX, pozY}, ""};
                coverFrom(pozX, pozY, sortedWords[i].first, 0, sortedWords[i].second, 1);
            }
            else
            {
                int poc = 0;
                int len = 0;
                string currentString = "";

                for (int j = previousMoves.size() - sortedWords[i-1].first.size(); j < previousMoves.size(); j++)
                {
                    int poz = j - previousMoves.size() + sortedWords[i-1].first.size();
                    currentString+= sortedWords[i-1].first[poz];
                    if (j == previousMoves.size() -1 || previousMoves[j].first == startX)
                    {
                        int len1 = pref(currentString, sortedWords[i].first);
                        if (len1>len)
                        {
                            len = len1;
                            poc = j;
                        }
                    }
                }

                reverse(sortedWords[i].first.begin(), sortedWords[i].first.end());
                currentString = "";

                for (int j = previousMoves.size() - sortedWords[i-1].first.size(); j < previousMoves.size(); j++)
                {
                    int poz = j - previousMoves.size() + sortedWords[i-1].first.size();
                    currentString+= sortedWords[i-1].first[poz];
                    if (j == previousMoves.size() -1 || previousMoves[j].first == startX)
                    {
                        int len1 = pref(currentString, sortedWords[i].first);
                        if (len1>len)
                        {
                            len = len1;
                            poc = j;
                            reversedMode = 1;
                        }
                    }
                }

                if (!reversedMode)
                    reverse(sortedWords[i].first.begin(), sortedWords[i].first.end());

                string s = "";
                if (len == 0)
                {
                    previousMoves.pb({pozX, pozY});
                    curMoves[sortedWords[i].second] = {{pozX, pozY}, ""};
                    coverFrom(pozX, pozY, sortedWords[i].first, 0, sortedWords[i].second, 1);
                    continue;
                }

                for (int j = len-1; j < sortedWords[i].first.size(); j++)
                    s+=sortedWords[i].first[j];

                pozX = previousMoves[poc].first;
                pozY = previousMoves[poc].second;

                curMoves[sortedWords[i].second] = {{previousMoves[poc - len + 1].first, previousMoves[poc - len + 1].second}, ""};

                for (int j = poc - len + 1 ; j<=poc; j++)
                    previousMoves.pb(previousMoves[j]);

                for (int j = poc - len +2 ; j<= poc; j++)
                {
                    int xi1 = previousMoves[j-1].first;
                    int yi1 = previousMoves[j-1].second;
                    int xi2 = previousMoves[j].first;
                    int yi2 = previousMoves[j].second;

                    curMoves[sortedWords[i].second].second+=from_to(xi2 - xi1, yi2 - yi1);
                }

                coverFrom(pozX, pozY, s, 0, sortedWords[i].second, 1);
            }

            if (reversedMode)
            {
                int idx = sortedWords[i].second;
                badMode[i] = 1;

                int trenX = curMoves[idx].first.first;
                int trenY = curMoves[idx].first.second;
                for (auto j = 0; j< curMoves[idx].second.size(); j++)
                {
                    if (curMoves[idx].second[j] =='L')
                    {
                        curMoves[idx].second[j] = 'R';
                        trenY--;
                    }
                    else if (curMoves[idx].second[j] == 'R')
                    {
                        curMoves[idx].second[j] = 'L';
                        trenY++;
                    }
                    else if (curMoves[idx].second[j] =='U')
                    {
                        curMoves[idx].second[j] = 'D';
                        trenX--;
                    }
                    else if (curMoves[idx].second[j] == 'D')
                    {
                        curMoves[idx].second[j] = 'U';
                        trenX++;
                    }
                }


                if (curMoves[idx].second.size())
                    reverse(curMoves[idx].second.begin(), curMoves[idx].second.end());
                curMoves[idx].first = {trenX, trenY};
            }
        }

        int curScore = calcScore();
        if (curScore <  bestAns)
            replaceBest();

        for (int i=0; i<n; i++)
            if (badMode[i])
            {
                badMode[i] = 0;
                reverse(sortedWords[i].first.begin(), sortedWords[i].first.end());
            }
        random_shuffle(sortedWords, sortedWords + n);
    }
}

int main()
{
    read_data();

    startTime = clock();

    initializer();

    solve1();

    print_data();

    return 0;
}