#define re register
#include<bits/stdc++.h>
using namespace std;

const int nmax=5e2+42;

double T=clock(),output_coeff=1/1e5;

double TL;

int n,m,q;

int row[nmax],col[nmax];

int inp[nmax][nmax],b[nmax][nmax];

inline char nc() {
    static char buf[100000],*p1,*p2;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
int rd() {
    int x=0; char ch=nc();
    while(ch<'0'||ch>'9') ch=nc();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=nc();
    return x;
}

/*
void read(int &ret)
{
    ret=0;

    char c=getchar();
    while(isdigit(c)==0)c=getchar();

    while(isdigit(c))
    {
        ret=ret*10+c-'0';
        c=getchar();
    }
}
*/

long long score=0;

struct line
{
    char type;
    int which,k;
    long long diff,total_diff;
};

vector<line> outp;

line make_line(char type,int which,int k,long long diff,long long total_diff)
{
    line ret;
    ret.type=type;
    ret.which=which;
    ret.k=k;
    ret.diff=diff;
    ret.total_diff=total_diff;
    return ret;
}

int help[nmax];

long long now_row[nmax][nmax]/*which, k*/,now_col[nmax][nmax]/*k, which*/;
long long old_row[nmax],old_col[nmax];

void recalc_old()
{
    memset(old_row,0,sizeof(old_row));
    memset(old_col,0,sizeof(old_col));

    //row
    for(int which=1;which<=n;which++)
    {
        for(int j=1;j<=m;j++)
            old_row[which]+=inp[which][j]*b[which][j];
    }

    //column
    for(int i=1;i<=n;i++)
        for(int which=1;which<=m;which++)
        {
            old_col[which]+=inp[i][which]*b[i][which];
        }

}

void push(char type,int which,int k)
{
    if(type=='R')
    {
        //column subtract
        for(int k_now=1;k_now<n;k_now++)
        {
            int pos=which-k_now;
            if(pos<=0)pos=pos+n;

            for(int j=1;j<=m;j++)
            {
                now_col[k_now][j]-=inp[which][j]*b[pos][j];
            }
        }

        //update
        for(int j=1;j<=m;j++)
        {
            int pos=j-k;
            if(pos<=0)pos+=m;

            help[pos]=inp[which][j];
        }

        for(int j=1;j<=m;j++)
        {
            old_row[which]-=inp[which][j]*b[which][j];
            old_col[j]-=inp[which][j]*b[which][j];

            inp[which][j]=help[j];

            old_row[which]+=inp[which][j]*b[which][j];
            old_col[j]+=inp[which][j]*b[which][j];
        }

        for(int j=1;j<m;j++)
            now_row[which][j]=row[which];

        //row - rebuild only which
        for(int k_now=1;k_now<m;k_now++)
            for(int j=1;j<=m;j++)
            {
                int pos=j-k_now;
                if(pos<=0)pos+=m;

                now_row[which][k_now]+=inp[which][j]*b[which][pos];
            }

        //column add
        for(int k_now=1;k_now<n;k_now++)
            for(int j=1;j<=m;j++)
            {
                int pos=which-k_now;
                if(pos<=0)pos=pos+n;

                now_col[k_now][j]+=inp[which][j]*b[pos][j];
            }
    }
    else//type='C'
    {
        //row subtract
        for(int i=1;i<=n;i++)
            for(int k_now=1;k_now<m;k_now++)
            {
                int pos=which-k_now;
                if(pos<=0)pos+=m;

                now_row[i][k_now]-=inp[i][which]*b[i][pos];
            }


        //update
        for(int i=1;i<=n;i++)
        {
            int pos=i-k;
            if(pos<=0)pos+=n;

            help[pos]=inp[i][which];
        }

        for(int i=1;i<=n;i++)
        {
            old_row[i]-=inp[i][which]*b[i][which];
            old_col[which]-=inp[i][which]*b[i][which];

            inp[i][which]=help[i];

            old_row[i]+=inp[i][which]*b[i][which];
            old_col[which]+=inp[i][which]*b[i][which];
        }

        for(int i=1;i<n;i++)
            now_col[i][which]=col[which];

        //column - rebuild only which
        for(int k_now=1;k_now<n;k_now++)
            for(int i=1;i<=n;i++)
            {
                int pos=i-k_now;
                if(pos<=0)pos+=n;

                now_col[k_now][which]+=inp[i][which]*b[pos][which];
            }

        //row add
        for(int i=1;i<=n;i++)
            for(int k_now=1;k_now<m;k_now++)
            {
                int pos=which-k_now;
                if(pos<=0)pos+=m;

                now_row[i][k_now]+=inp[i][which]*b[i][pos];
            }
    }

    //recalc_old();
}

//https://github.com/radoslav11/Coding-Library/blob/master/math/fft.cpp
//--------------------
const double PI = acos(-1);
const int MAXN = (1 << 11);

struct complex_base
{
	double x, y;
	complex_base(double _x = 0, double _y = 0) { x = _x; y = _y; }
	friend complex_base operator-(const complex_base &a, const complex_base &b) { return complex_base(a.x - b.x, a.y - b.y); }
	friend complex_base operator+(const complex_base &a, const complex_base &b) { return complex_base(a.x + b.x, a.y + b.y); }
	friend complex_base operator*(const complex_base &a, const complex_base &b) { return complex_base(a.x * b.x - a.y * b.y, a.y * b.x + b.y * a.x); }
	friend void operator/=(complex_base &a, const double &P) { a.x /= P; a.y /= P; }
};

int bit_rev[MAXN];
int last_n_fft = -1, ilast_n_fft = -1;
complex_base root[MAXN], iroot[MAXN];

void fft(complex_base *a, int lg)
{
	int n = (1 << lg);
	if(last_n_fft != n)
	{
		double ang = 2 * PI / n;
		for(int i = 0; i < (n >> 1); i++)
			root[i] = complex_base(cos(ang * i), sin(ang * i));

		last_n_fft = n;
	}

	for(int i = 1; i < n; i++)
	{
		bit_rev[i] = (bit_rev[i >> 1] >> 1) | ((i & 1) << (lg - 1));
		if(bit_rev[i] < i) swap(a[i], a[bit_rev[i]]);
	}

	for(int len = 2; len <= n; len <<= 1)
	{
		int step = (n / len);
		for(int j = 0; j < (len >> 1); j++)
			for(int i = 0; i < n; i += len)
			{
				complex_base u = a[i + j], v = root[step * j] * a[i + j + (len >> 1)];
				a[i + j] = u + v;
				a[i + j + (len >> 1)] = u - v;
			}
	}
}

void inv_fft(complex_base *a, int lg)
{
	int n = (1 << lg);
	if(ilast_n_fft != n)
	{
		double ang = -2 * PI / n;
		for(int i = 0; i < (n >> 1); i++)
			iroot[i] = complex_base(cos(ang * i), sin(ang * i));

		ilast_n_fft = n;
	}

	for(int i = 1; i < n; i++)
	{
		bit_rev[i] = (bit_rev[i >> 1] >> 1) | ((i & 1) << (lg - 1));
		if(bit_rev[i] < i) swap(a[i], a[bit_rev[i]]);
	}

	for(int len = 2; len <= n; len <<= 1)
	{
		int step = (n / len);
		for(int j = 0; j < (len >> 1); j++)
			for(int i = 0; i < n; i += len)
			{
				complex_base u = a[i + j], v = iroot[step * j] * a[i + j + (len >> 1)];
				a[i + j] = u + v;
				a[i + j + (len >> 1)] = u - v;
			}
	}

	for(int i = 0; i < n; i++)
		a[i] /= n;
}

complex_base A[MAXN], B[MAXN];

vector<long long> mult(vector<int> a, vector<int> b)
{
	if(a.size() * b.size() <= 256)
	{
		vector<long long> ans(a.size() + b.size(), 0);
		for(int i = 0; i < (int)a.size(); i++)
			for(int j = 0; j < (int)b.size(); j++)
				ans[i + j] += a[i] * b[j];

		return ans;
	}

	int lg = 0; while((1 << lg) < (int)(a.size() + b.size())) ++lg;
	for(int i = 0; i < (1 << lg); i++) A[i] = B[i] = complex_base(0, 0);
	for(int i = 0; i < (int)a.size(); i++) A[i] = complex_base(a[i], 0);
	for(int i = 0; i < (int)b.size(); i++) B[i] = complex_base(b[i], 0);

	fft(A, lg); fft(B, lg);
	for(int i = 0; i < (1 << lg); i++)
		A[i] = A[i] * B[i];
	inv_fft(A, lg);

	vector<long long> ans(a.size() + b.size(), 0);
	for(int i = 0; i < (int)ans.size(); i++)
		ans[i] = (long long)(A[i].x + 0.5);

	return ans;
}
//--------------------




line get_line_1()
{
    char type;
    int best_which,best_k;

    long long best_diff=-1e18;
    //test row
        for(int which=1;which<=n;which++)
        {
            for(int j=1;j<m;j++)
            {
                long long diff_now=old_row[which]-now_row[which][j];

                if(best_diff<diff_now)
                {
                    type='R';
                    best_diff=diff_now;
                    best_which=which;
                    best_k=j;
                }
            }
        }

        //test column
        for(int i=1;i<n;i++)
        {
            for(int which=1;which<=m;which++)
            {
                long long diff_now=old_col[which]-now_col[i][which];

                if(best_diff<diff_now)
                {
                    type='C';
                    best_diff=diff_now;
                    best_which=which;
                    best_k=i;
                }
            }
        }
    return make_line(type,best_which,best_k,best_diff,best_diff);
}

int TAKE=15;

vector< pair<int,int> > get_best_start_row()
{
        vector< pair<long long, pair<int,int> > > best_start={};

        for(int which_first=1;which_first<=n;which_first++)
            //for(int k_first=1;k_first<m;k_first++)
            {
                int k_first=1;
                for(int i=1;i<m;i++)
                    if(now_row[which_first][k_first]>now_row[which_first][i])k_first=i;

                best_start.push_back({-(old_row[which_first]-now_row[which_first][k_first]),{which_first,k_first}});
            }

        sort(best_start.begin(),best_start.end());

        //for(auto w:best_start)cout<<w.first<<" "<<w.second.first<<" "<<w.second.second<<endl;

        vector< pair<int,int> > ret={};
        for(int i=0;i<TAKE&&i<best_start.size();i++)
            ret.push_back(best_start[i].second);

        return ret;
}

vector< pair<int,int> > get_best_start_col()
{
        vector< pair<long long, pair<int,int> > > best_start={};

            for(int which_first=1;which_first<=m;which_first++)
            //for(int k_first=1;k_first<n;k_first++)
            {
                int k_first=1;
                for(int j=1;j<n;j++)
                    if(now_col[k_first][which_first]>now_col[j][which_first])k_first=j;

                //long long diff_first=old_col[which_first]-now_col[k_first][which_first];
                best_start.push_back({-(old_col[which_first]-now_col[k_first][which_first]),{k_first,which_first}});
            }

        sort(best_start.begin(),best_start.end());

        vector< pair<int,int> > ret={};
        for(int i=0;i<TAKE&&i<best_start.size();i++)
            ret.push_back(best_start[i].second);

        return ret;
}

line get_line_one_half()
{
        char type='R';
        long long best_diff=-1e18;
        int best_which=0;
        int best_k=0;

        long long best_sub=0;

        for(auto cur:get_best_start_row())
        {
            int which_first=cur.first;
            int k_first=cur.second;

                long long diff_first=old_row[which_first]-now_row[which_first][k_first];

                push('R',which_first,k_first);

                if(best_diff<diff_first)
                {
                    type='R';
                    best_diff=diff_first;
                    best_which=which_first;
                    best_k=k_first;

                    best_sub=diff_first;
                }

                if(q>=2)
                {
                    line cur=get_line_1();

                    if(best_diff<diff_first+cur.diff)
                    {
                        type='R';
                        best_diff=diff_first+cur.diff;
                        best_which=which_first;
                        best_k=k_first;

                        best_sub=diff_first;
                    }
                }

                push('R',which_first,m-k_first);
            }

        for(auto cur:get_best_start_col())
        {
            int which_first=cur.second;
            int k_first=cur.first;

                long long diff_first=old_col[which_first]-now_col[k_first][which_first];

                push('C',which_first,k_first);

                if(best_diff<diff_first)
                {
                    type='C';
                    best_diff=diff_first;
                    best_which=which_first;
                    best_k=k_first;

                    best_sub=diff_first;
                }

                if(q>=2)
                {
                    line cur=get_line_1();

                    if(best_diff<diff_first+cur.diff)
                    {
                        type='C';
                        best_diff=diff_first+cur.diff;
                        best_which=which_first;
                        best_k=k_first;

                        best_sub=diff_first;
                    }
                }

                push('C',which_first,n-k_first);
            }
        return make_line(type,best_which,best_k,best_sub,best_diff);
}

line get_line_2()
{
        char type='R';
        long long best_diff=-1e18;
        int best_which=0;
        int best_k=0;

        long long best_sub=0;

        for(int which_first=1;which_first<=n;which_first++)
            for(int k_first=1;k_first<m;k_first++)
            {
                long long diff_first=old_row[which_first]-now_row[which_first][k_first];

                push('R',which_first,k_first);

                if(best_diff<diff_first)
                {
                    type='R';
                    best_diff=diff_first;
                    best_which=which_first;
                    best_k=k_first;

                    best_sub=diff_first;
                }

                if(q>=2)
                {
                    line cur=get_line_1();

                    if(best_diff<diff_first+cur.diff)
                    {
                        type='R';
                        best_diff=diff_first+cur.diff;
                        best_which=which_first;
                        best_k=k_first;

                        best_sub=diff_first;
                    }
                }

                push('R',which_first,m-k_first);
            }


        for(int which_first=1;which_first<=m;which_first++)
            for(int k_first=1;k_first<n;k_first++)
            {
                long long diff_first=old_col[which_first]-now_col[k_first][which_first];

                push('C',which_first,k_first);

                if(best_diff<diff_first)
                {
                    type='C';
                    best_diff=diff_first;
                    best_which=which_first;
                    best_k=k_first;

                    best_sub=diff_first;
                }

                if(q>=2)
                {
                    line cur=get_line_1();

                    if(best_diff<diff_first+cur.diff)
                    {
                        type='C';
                        best_diff=diff_first+cur.diff;
                        best_which=which_first;
                        best_k=k_first;

                        best_sub=diff_first;
                    }
                }

                push('C',which_first,n-k_first);
            }
        return make_line(type,best_which,best_k,best_sub,best_diff);
}

line get_line_3()
{
        char type='R';
        long long best_diff=-1e18;
        int best_which=0;
        int best_k=0;

        long long best_sub=0;

        for(int which_first=1;which_first<=n;which_first++)
            for(int k_first=1;k_first<m;k_first++)
            {
                long long diff_first=old_row[which_first]-now_row[which_first][k_first];

                push('R',which_first,k_first);

                if(best_diff<diff_first)
                {
                    type='R';
                    best_diff=diff_first;
                    best_which=which_first;
                    best_k=k_first;

                    best_sub=diff_first;
                }

                q--;

                if(q>=1)
                {
                    line cur=get_line_2();

                    if(best_diff<diff_first+cur.total_diff)
                    {
                        type='R';
                        best_diff=diff_first+cur.total_diff;
                        best_which=which_first;
                        best_k=k_first;

                        best_sub=diff_first;
                    }
                }

                q++;

                push('R',which_first,m-k_first);
            }


        for(int which_first=1;which_first<=m;which_first++)
            for(int k_first=1;k_first<n;k_first++)
            {
                long long diff_first=old_col[which_first]-now_col[k_first][which_first];

                push('C',which_first,k_first);

                if(best_diff<diff_first)
                {
                    type='C';
                    best_diff=diff_first;
                    best_which=which_first;
                    best_k=k_first;

                    best_sub=diff_first;
                }

                q--;

                if(q>=1)
                {
                    line cur=get_line_2();

                    if(best_diff<diff_first+cur.total_diff)
                    {
                        type='C';
                        best_diff=diff_first+cur.total_diff;
                        best_which=which_first;
                        best_k=k_first;

                        best_sub=diff_first;
                    }
                }

                q++;

                push('C',which_first,n-k_first);
            }
        return make_line(type,best_which,best_k,best_sub,best_diff);
}

void solve_very_small()
{
    pair<long long,int> best={score,0};

    TL=4.6;

    while(q&&1.0*(clock()-T)/CLOCKS_PER_SEC+outp.size()*output_coeff<TL)
    {
        line cur=get_line_3();


        outp.push_back(cur);

        score=score-cur.diff;

        q--;

        //cout<<"SZ "<<outp.size()<<" "<<score<<endl;

        push(cur.type,cur.which,cur.k);

        if(best.first>score)
        {
            best={score,outp.size()};
        }

        //cout<<score<<" "<<cur.type<<" "<<cur.which<<" "<<cur.k<<" "<<cur.diff<<" "<<cur.total_diff<<endl;
        //cout<<1.0*(clock()-T)/CLOCKS_PER_SEC<<endl;
    }

    while(outp.size()>best.second)outp.pop_back();
    score=best.first;

    //cout<<"score= "<<score<<endl;

    printf("%i\n",outp.size());
    for(auto w:outp)
        printf("%c %i %i\n",w.type,w.which,w.k);

    exit(0);
}


void solve_small()
{
    pair<long long,int> best={score,0};

    TL=4.75;

    while(q&&1.0*(clock()-T)/CLOCKS_PER_SEC+outp.size()*output_coeff<TL)
    {
        line cur=get_line_2();

        outp.push_back(cur);

        score=score-cur.diff;

        q--;

        //cout<<"SZ "<<outp.size()<<" "<<score<<endl;

        push(cur.type,cur.which,cur.k);

        if(best.first>score)
        {
            best={score,outp.size()};
        }

        //cout<<score<<" "<<cur.type<<" "<<cur.which<<" "<<cur.k<<" "<<cur.diff<<" "<<cur.total_diff<<endl;
        //cout<<1.0*(clock()-T)/CLOCKS_PER_SEC<<endl;
    }

    while(outp.size()>best.second)outp.pop_back();
    score=best.first;

    //cout<<"score= "<<score<<endl;

    printf("%i\n",outp.size());
    for(auto w:outp)
        printf("%c %i %i\n",w.type,w.which,w.k);

    exit(0);
}

void solve_middle()
{
    pair<long long,int> best={score,0};

    TL=4.825;

    TAKE=15*2*100*100/(n*n+m*m);

    //cout<<"TAKE= "<<TAKE<<endl;

    while(q&&1.0*(clock()-T)/CLOCKS_PER_SEC+outp.size()*output_coeff<TL)
    {
        line cur=get_line_one_half();

        outp.push_back(cur);

        score=score-cur.diff;

        q--;

        //cout<<"SZ "<<outp.size()<<" "<<score<<endl;

        push(cur.type,cur.which,cur.k);

        if(best.first>score)
        {
            best={score,outp.size()};
        }

        //cout<<score<<" "<<cur.type<<" "<<cur.which<<" "<<cur.k<<" "<<cur.diff<<" "<<cur.total_diff<<endl;
        //cout<<1.0*(clock()-T)/CLOCKS_PER_SEC<<endl;
    }

    while(outp.size()>best.second)outp.pop_back();
    score=best.first;

    //cout<<"score= "<<score<<endl;

    printf("%i\n",outp.size());
    for(auto w:outp)
        printf("%c %i %i\n",w.type,w.which,w.k);

    //cout<<1.0*(clock()-T)/CLOCKS_PER_SEC<<endl;

    exit(0);

}

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

    n=rd();
    m=rd();
    q=rd();

    for(int i=1;i<=n;i++)row[i]=rd();

    for(int j=1;j<=m;j++)col[j]=rd();

    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            inp[i][j]=rd();

    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            b[i][j]=rd();

    //cout<<n<<" "<<m<<" "<<q<<endl;

    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            score+=inp[i][j]*b[i][j];
            //cout<<inp[i][j]<<" * "<<b[i][j]<<endl;
        }

    //test row
    for(int which=1;which<=n;which++)
        {
            vector<int> LHS(m+1,0);
            for(int j=1;j<=m;j++)LHS[j]=inp[which][j];

            vector<int> RHS(m+1,0);
            for(int j=1;j<=m;j++)RHS[m-j]=b[which][j];

            vector<long long> help=mult(LHS,RHS);

            for(int i=1;i<=m;i++)now_row[which][i]=row[which];

            for(int i=1;i<help.size();i++)
            {
                int pos=i;

                pos=pos%m;
                if(pos==0)pos=m;

                now_row[which][pos]+=help[i];
            }
        }

    //test column
    for(int which=1;which<=m;which++)
        {
            vector<int> LHS(n+1,0);
            for(int i=1;i<=n;i++)LHS[i]=inp[i][which];

            vector<int> RHS(n+1,0);
            for(int i=1;i<=n;i++)RHS[n-i]=b[i][which];

            vector<long long> help=mult(LHS,RHS);

            for(int j=1;j<=n;j++)now_col[j][which]=col[which];

            for(int i=1;i<help.size();i++)
            {
                int pos=i;

                pos=pos%n;
                if(pos==0)pos=n;

                now_col[pos][which]+=help[i];
            }
        }

    recalc_old();

    if(n<=10&&m<=10)
    {
        solve_very_small();
        return 0;
    }

    if(n<=30&&m<=30)
    {
        solve_small();
        return 0;
    }

    if(n<=100&&m<=100)
    {
        solve_middle();
        return 0;
    }

    pair<long long,int> best={score,0};

    TL=4.85;

    while(q&&1.0*(clock()-T)/CLOCKS_PER_SEC+outp.size()*output_coeff<TL)
    {
        line cur=get_line_1();

        //if(best_diff==0)break;

        outp.push_back(cur);

        score=score-cur.diff;

        q--;

        //cout<<"SZ "<<outp.size()<<" "<<score<<endl;

        push(cur.type,cur.which,cur.k);

        if(best.first>score)
        {
            best={score,outp.size()};
        }

        //cout<<score<<" "<<cur.type<<" "<<cur.which<<" "<<cur.k<<" "<<cur.diff<<" "<<cur.total_diff<<endl;
        //cout<<1.0*(clock()-T)/CLOCKS_PER_SEC<<endl;
    }

    while(outp.size()>best.second)outp.pop_back();
    score=best.first;

    //cout<<"score= "<<score<<endl;

    printf("%i\n",outp.size());
    for(auto w:outp)
        printf("%c %i %i\n",w.type,w.which,w.k);

    //cout<<1.0*(clock()-T)/CLOCKS_PER_SEC<<endl;

    return 0;
}