#include<bits/stdc++.h>
#define forOneToN(i, n)         for(int i = 1; i <= n; i++)
#define forZeroToNminus(i, n)   for(int i = 0; i < n; i++)
#define forNToOne(i, n)         for(int i = n; i >= 1; i--)
#define forNminusToZero(i, n)   for(int i = n-1; i >= 0; i--)

#define makepair                make_pair
#define pushback                push_back

//Test Code
#define test                    cout <<"I am here" << endl;

using namespace std;
void fastInputOutput(){ios_base::sync_with_stdio(false);cin.tie(NULL);}

typedef long long ll;
typedef double db;

typedef vector<int>                                                             vii;
typedef vector<long long>                                                       vll;
typedef vector< pair<int, int> >                                                vpii;
typedef vector< pair<long long, long long> >                                    vpll;
typedef vector< pair<long long, int> >                                          vpli;
typedef vector< pair<int, long long> >                                          vpil;
typedef pair<int, int>                                                          pii;
typedef pair<long long, long long>                                              pll;
typedef pair<long long, int>                                                    pli;
typedef pair<int, long long>                                                    pil;
typedef map<int, int>                                                           mii;
typedef map<long long, long long>                                               mll;
typedef map<long long, int>                                                     mli;
typedef map<int, long long>                                                     mil;
typedef multimap<int, int>                                                      mmii;
typedef multimap<long long, int>                                                mmli;
typedef multimap<int, long long>                                                mmil;
typedef multimap<long long, long long>                                          mmll;
typedef set<int>                                                                si;
typedef set<long long>                                                          sll;
typedef multiset<int>                                                           msi;
typedef multiset<long long>                                                     msll;
typedef set<long long, greater<long long> >                                     slld;
typedef set<int, greater<int> >                                                 sid;
typedef multiset<int, greater<int> >                                            msid;
typedef multiset<long long, greater<long long> >                                mslld;
typedef stack<long long>                                                        stll;
typedef stack<int>                                                              sti;
typedef queue<long long>                                                        qll;
typedef queue<int>                                                              qi;
typedef priority_queue<long long>                                               maxpqll;
typedef priority_queue<int>                                                     maxpqi;
typedef priority_queue<long long, vector<long long>, greater<long long> >       minpqll;
typedef priority_queue<int, vector<int>, greater<int> >                         minmpqi;
typedef priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> Minpairpq;

ll GCD(ll a, ll b){ll gcd, g;g = __gcd(a, b);return g;}
ll gcd(ll a, ll b){if(b == 0){return a;}else{return gcd(b, a%b);}}
ll extended_gcd(ll a, ll b, ll *x, ll *y){if(a == 0){*x = 0;*y = 1;return b;}ll x1, y1;ll d = extended_gcd(b%a, a, &x1, &y1);*x = y1-(b/a)*x1;*y = x1;return d;}
ll LCM(ll a, ll b){ll gcd, g;g = __gcd(a, b);return (a/g)*b;}
ll PowFun(ll base, ll power){ll ans = 1;for(int i = 1; i <= power; i++){ans *= base;}return ans;}
/*This is better power function here used binary exponentiation*/
ll MadeFun(ll b, ll p){if(p == 0){return 1;}else if(p%2 == 0){return MadeFun(b*b, p/2);}else{return b*MadeFun(b*b, (p-1)/2);}}
ll Set(ll n, ll pos){return n = n|(1<<pos);}
ll Reset(ll n, ll pos){return n = n& ~(1<<pos);}
bool Check(ll n, ll pos){return (bool)(n&(1<<pos));}

const ll INF_LONG = 1LL<<61;
const unsigned int inf_int = 1<<31;
const ll mod = 1e9+7;
double phi = acos(-1);

//own compare function structure for set
struct cmp_for_set_and_Semilar
{
    bool operator()(pair<int, int> a, pair<int, int> b)
    {
        return (a.first > b.first);
    }
};
//own compare function structure for vector pair
bool cmp(const pair<int, int> &a, const pair<int, int> &b)
{
    if(a.first != b.first)
    {
        return a.first < b.first;
    }
    return a.second > b.second;
}

long long BinaryEx(long long a, long long b)
{
    long long ans = 1;
    while(b)
    {
        if(b%2 == 0)
        {
            a = (a*a);
            b /= 2;
        }
        else
        {
            ans = (ans*a);
            b--;
        }
    }
    return ans;
}

long long mod_inverse(long long a)
{
    return BinaryEx(a, mod-2);
}

vector<pair<int, int>>vp;
int mark[3000005] = {1};
int index[3][3000005] = {};
int pos = 0;
int m = 0;
bool isSubsequence(string str1, string str2, int pos1, int pos2)
{
    //int m = str1.size();
    int n = str2.size();
    int j = pos1;
    int t1 = 0, t2 = 0;
    for(int i = pos2; i < n && j < m; i++)
    {
        if(str1[j] == str2[i] && j < m)
        {
            //j++;
            //vp.push_back(make_pair(j, i));
            pos++;
            index[0][pos] = j; index[1][pos] = i;
            //pos++;
            j++;
            //pos1 = j; pos2 = i;
            //t1 = j-1; t2 = i-1;
        }
    }
    //pos1 = t1; pos2 = t2;
    return (j == m);
}
void solve()
{
    string str; cin >> str;
    int n = str.size();
    cout << 3 << endl;
    cout << "L 2" << endl;
    cout << "R " << n+(n-2)-1 << endl;
    cout << "R " << n+(n-2) << endl;
}
int main()
{
    fastInputOutput();
    //int t; cin >> t;while(t--) solve();
    solve();
    return 0;
}


#include<bits/stdc++.h>
#define forOneToN(i, n)         for(int i = 1; i <= n; i++)
#define forZeroToNminus(i, n)   for(int i = 0; i < n; i++)
#define forNToOne(i, n)         for(int i = n; i >= 1; i--)
#define forNminusToZero(i, n)   for(int i = n-1; i >= 0; i--)

#define makepair                make_pair
#define pushback                push_back

//Test Code
#define test                    cout <<"I am here" << endl;

using namespace std;
void fastInputOutput(){ios_base::sync_with_stdio(false);cin.tie(NULL);}

typedef long long ll;
typedef double db;

typedef vector<int>                                                             vii;
typedef vector<long long>                                                       vll;
typedef vector< pair<int, int> >                                                vpii;
typedef vector< pair<long long, long long> >                                    vpll;
typedef vector< pair<long long, int> >                                          vpli;
typedef vector< pair<int, long long> >                                          vpil;
typedef pair<int, int>                                                          pii;
typedef pair<long long, long long>                                              pll;
typedef pair<long long, int>                                                    pli;
typedef pair<int, long long>                                                    pil;
typedef map<int, int>                                                           mii;
typedef map<long long, long long>                                               mll;
typedef map<long long, int>                                                     mli;
typedef map<int, long long>                                                     mil;
typedef multimap<int, int>                                                      mmii;
typedef multimap<long long, int>                                                mmli;
typedef multimap<int, long long>                                                mmil;
typedef multimap<long long, long long>                                          mmll;
typedef set<int>                                                                si;
typedef set<long long>                                                          sll;
typedef multiset<int>                                                           msi;
typedef multiset<long long>                                                     msll;
typedef set<long long, greater<long long> >                                     slld;
typedef set<int, greater<int> >                                                 sid;
typedef multiset<int, greater<int> >                                            msid;
typedef multiset<long long, greater<long long> >                                mslld;
typedef stack<long long>                                                        stll;
typedef stack<int>                                                              sti;
typedef queue<long long>                                                        qll;
typedef queue<int>                                                              qi;
typedef priority_queue<long long>                                               maxpqll;
typedef priority_queue<int>                                                     maxpqi;
typedef priority_queue<long long, vector<long long>, greater<long long> >       minpqll;
typedef priority_queue<int, vector<int>, greater<int> >                         minmpqi;
typedef priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> Minpairpq;

ll GCD(ll a, ll b){ll gcd, g;g = __gcd(a, b);return g;}
ll gcd(ll a, ll b){if(b == 0){return a;}else{return gcd(b, a%b);}}
ll extended_gcd(ll a, ll b, ll *x, ll *y){if(a == 0){*x = 0;*y = 1;return b;}ll x1, y1;ll d = extended_gcd(b%a, a, &x1, &y1);*x = y1-(b/a)*x1;*y = x1;return d;}
ll LCM(ll a, ll b){ll gcd, g;g = __gcd(a, b);return (a/g)*b;}
ll PowFun(ll base, ll power){ll ans = 1;for(int i = 1; i <= power; i++){ans *= base;}return ans;}
/*This is better power function here used binary exponentiation*/
ll MadeFun(ll b, ll p){if(p == 0){return 1;}else if(p%2 == 0){return MadeFun(b*b, p/2);}else{return b*MadeFun(b*b, (p-1)/2);}}
ll Set(ll n, ll pos){return n = n|(1<<pos);}
ll Reset(ll n, ll pos){return n = n& ~(1<<pos);}
bool Check(ll n, ll pos){return (bool)(n&(1<<pos));}

const ll INF_LONG = 1LL<<61;
const unsigned int inf_int = 1<<31;
const ll mod = 1e9+7;
double phi = acos(-1);

//own compare function structure for set
struct cmp_for_set_and_Semilar
{
    bool operator()(pair<int, int> a, pair<int, int> b)
    {
        return (a.first > b.first);
    }
};
//own compare function structure for vector pair
bool cmp(const pair<int, int> &a, const pair<int, int> &b)
{
    if(a.first != b.first)
    {
        return a.first > b.first;
    }
    return a.second > b.second;
}

long long BinaryEx(long long a, long long b)
{
    long long ans = 1;
    while(b)
    {
        if(b%2 == 0)
        {
            a = (a*a)%mod;
            b /= 2;
        }
        else
        {
            ans = (ans*a)%mod;
            b--;
        }
    }
    return ans;
}
long long mod_inverse(long long a)
{
    return BinaryEx(a, mod-2);
}

void solve()
{
    int n; cin >> n;
    char grid[300][300] = {};
    for(int i = 1; i <= n; i++)
    {
        string str; cin >> str;
        forZeroToNminus(j, n)
        {
            grid[i][j+1] = str[j];
        }
    }
    set<char>s;
    s.insert(grid[1][2]); s.insert(grid[2][1]);
    s.insert(grid[n][n-1]); s.insert(grid[n-1][n]);
    if(s.size() == 1)
    {
        cout << 2 << endl;
        cout << "1 2" << endl;
        cout << "2 1" << endl;
        return;
    }
    if(grid[1][2] == grid[2][1] && grid[n][n-1] == grid[n-1][n])
    {
        cout << 0 << endl;
        return;
    }
    if(grid[1][2] == grid[2][1] && grid[n][n-1] != grid[n-1][n])
    {
        if(grid[1][2] == grid[n][n-1])
        {
            cout << 1 << endl;
            cout << n << " " << n-1 << endl;
        }
        else
        {
            cout << 1 << endl;
            //cout << grid[n][n-1] << endl;
            cout << n-1 << " " << n << endl;
        }
        return;
    }
    if(grid[1][2] != grid[2][1] && grid[n][n-1] == grid[n-1][n])
    {
        if(grid[1][2] == grid[n][n-1])
        {
            cout << 1 << endl;
            //cout << grid[2][1] << endl;
            cout << 1 << " " << 2 << endl;
        }
        else
        {
            cout << 1 << endl;
            //out << grid[1][2] << endl;
            cout << 2 << " " << 1 << endl;
        }
        return;
    }
    if((grid[1][2] != grid[2][1]) && (grid[n][n-1] != grid[n-1][n]))
    {
        cout << 2 << endl;
        if(grid[1][2] == grid[n][n-1])
        {
            cout << "1 2" << endl;
            cout << n << " " << n-1 << endl;
        }
        else
        {
            cout << "1 2" << endl;
            cout << n-1 << " " << n << endl;
        }
    }
}
int main()
{
    fastInputOutput();
    int t; cin >> t;while(t--) solve();
    //solve();
    return 0;
}


#include<bits/stdc++.h>
#define forOneToN(i, n)         for(int i = 1; i <= n; i++)
#define forZeroToNminus(i, n)   for(int i = 0; i < n; i++)
#define forNToOne(i, n)         for(int i = n; i >= 1; i--)
#define forNminusToZero(i, n)   for(int i = n-1; i >= 0; i--)

#define makepair                make_pair
#define pushback                push_back

//Test Code
#define test                    cout <<"I am here" << endl;

using namespace std;
void fastInputOutput(){ios_base::sync_with_stdio(false);cin.tie(NULL);}

typedef long long ll;
typedef double db;

typedef vector<int>                                                             vii;
typedef vector<long long>                                                       vll;
typedef vector< pair<int, int> >                                                vpii;
typedef vector< pair<long long, long long> >                                    vpll;
typedef vector< pair<long long, int> >                                          vpli;
typedef vector< pair<int, long long> >                                          vpil;
typedef pair<int, int>                                                          pii;
typedef pair<long long, long long>                                              pll;
typedef pair<long long, int>                                                    pli;
typedef pair<int, long long>                                                    pil;
typedef map<int, int>                                                           mii;
typedef map<long long, long long>                                               mll;
typedef map<long long, int>                                                     mli;
typedef map<int, long long>                                                     mil;
typedef multimap<int, int>                                                      mmii;
typedef multimap<long long, int>                                                mmli;
typedef multimap<int, long long>                                                mmil;
typedef multimap<long long, long long>                                          mmll;
typedef set<int>                                                                si;
typedef set<long long>                                                          sll;
typedef multiset<int>                                                           msi;
typedef multiset<long long>                                                     msll;
typedef set<long long, greater<long long> >                                     slld;
typedef set<int, greater<int> >                                                 sid;
typedef multiset<int, greater<int> >                                            msid;
typedef multiset<long long, greater<long long> >                                mslld;
typedef stack<long long>                                                        stll;
typedef stack<int>                                                              sti;
typedef queue<long long>                                                        qll;
typedef queue<int>                                                              qi;
typedef priority_queue<long long>                                               maxpqll;
typedef priority_queue<int>                                                     maxpqi;
typedef priority_queue<long long, vector<long long>, greater<long long> >       minpqll;
typedef priority_queue<int, vector<int>, greater<int> >                         minmpqi;
typedef priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> Minpairpq;

ll GCD(ll a, ll b){ll gcd, g;g = __gcd(a, b);return g;}
ll gcd(ll a, ll b){if(b == 0){return a;}else{return gcd(b, a%b);}}
ll extended_gcd(ll a, ll b, ll *x, ll *y){if(a == 0){*x = 0;*y = 1;return b;}ll x1, y1;ll d = extended_gcd(b%a, a, &x1, &y1);*x = y1-(b/a)*x1;*y = x1;return d;}
ll LCM(ll a, ll b){ll gcd, g;g = __gcd(a, b);return (a/g)*b;}
ll PowFun(ll base, ll power){ll ans = 1;for(int i = 1; i <= power; i++){ans *= base;}return ans;}
/*This is better power function here used binary exponentiation*/
ll MadeFun(ll b, ll p){if(p == 0){return 1;}else if(p%2 == 0){return MadeFun(b*b, p/2);}else{return b*MadeFun(b*b, (p-1)/2);}}
ll Set(ll n, ll pos){return n = n|(1<<pos);}
ll Reset(ll n, ll pos){return n = n& ~(1<<pos);}
bool Check(ll n, ll pos){return (bool)(n&(1<<pos));}

const ll INF_LONG = 1LL<<61;
const unsigned int inf_int = 1<<31;
const ll mod = 1e9+7;
double phi = acos(-1);

//own compare function structure for set
struct cmp_for_set_and_Semilar
{
    bool operator()(pair<int, int> a, pair<int, int> b)
    {
        return (a.first > b.first);
    }
};
//own compare function structure for vector pair
bool cmp(const pair<int, int> &a, const pair<int, int> &b)
{
    if(a.first != b.first)
    {
        return a.first < b.first;
    }
    return a.second > b.second;
}

long long BinaryEx(long long a, long long b)
{
    long long ans = 1;
    while(b)
    {
        if(b%2 == 0)
        {
            a = (a*a);
            b /= 2;
        }
        else
        {
            ans = (ans*a);
            b--;
        }
    }
    return ans;
}

long long mod_inverse(long long a)
{
    return BinaryEx(a, mod-2);
}

vector<pair<int, int>>vp;
int mark[3000005] = {1};
int index[3][3000005] = {};
int pos = 0;
int m = 0;
bool isSubsequence(string str1, string str2, int pos1, int pos2)
{
    //int m = str1.size();
    int n = str2.size();
    int j = pos1;
    int t1 = 0, t2 = 0;
    for(int i = pos2; i < n && j < m; i++)
    {
        if(str1[j] == str2[i] && j < m)
        {
            //j++;
            //vp.push_back(make_pair(j, i));
            pos++;
            index[0][pos] = j; index[1][pos] = i;
            //pos++;
            j++;
            //pos1 = j; pos2 = i;
            //t1 = j-1; t2 = i-1;
        }
    }
    //pos1 = t1; pos2 = t2;
    return (j == m);
}
void solve()
{
    string str; cin >> str;
    string st = "";
    char c = str[1];
    for(int i = 1; i < str.size()-1; i++)
    {
        st += str[i];
    }
    reverse(st.begin(), st.end());
    for(int i = 0; i < st.size(); i++)
    {
        str += st[i];
    }
    vector<pair<char, int>>vp;
    vp.push_back(make_pair('R', 2));
    st = "";
    int pos = 0;
    bool ok = false;
    for(int i = 1; i < str.size()-1; i++)
    {
        st += str[i];
        if(c == str[i] && ok == false)
        {
            ok = true;
            pos = i+1;
        }
    }
    reverse(st.begin(), st.end());
    vp.push_back(make_pair('R', 2));
    vp.push_back(make_pair('R', pos));
    cout << vp.size() << endl;
    for(int i = 0; i < vp.size(); i++)
    {
        cout << vp[i].first << " " << vp[i].second << endl;
    }
    cout << c << st << str << endl;
}
int main()
{
    fastInputOutput();
    //int t; cin >> t;while(t--) solve();
    solve();
    return 0;
}


#include<bits/stdc++.h>
#define forOneToN(i, n)         for(int i = 1; i <= n; i++)
#define forZeroToNminus(i, n)   for(int i = 0; i < n; i++)
#define forNToOne(i, n)         for(int i = n; i >= 1; i--)
#define forNminusToZero(i, n)   for(int i = n-1; i >= 0; i--)

#define makepair                make_pair
#define pushback                push_back

//Test Code
#define test                    cout <<"I am here" << endl;

using namespace std;
void fastInputOutput(){ios_base::sync_with_stdio(false);cin.tie(NULL);}

typedef long long ll;
typedef double db;

typedef vector<int>                                                             vii;
typedef vector<long long>                                                       vll;
typedef vector< pair<int, int> >                                                vpii;
typedef vector< pair<long long, long long> >                                    vpll;
typedef vector< pair<long long, int> >                                          vpli;
typedef vector< pair<int, long long> >                                          vpil;
typedef pair<int, int>                                                          pii;
typedef pair<long long, long long>                                              pll;
typedef pair<long long, int>                                                    pli;
typedef pair<int, long long>                                                    pil;
typedef map<int, int>                                                           mii;
typedef map<long long, long long>                                               mll;
typedef map<long long, int>                                                     mli;
typedef map<int, long long>                                                     mil;
typedef multimap<int, int>                                                      mmii;
typedef multimap<long long, int>                                                mmli;
typedef multimap<int, long long>                                                mmil;
typedef multimap<long long, long long>                                          mmll;
typedef set<int>                                                                si;
typedef set<long long>                                                          sll;
typedef multiset<int>                                                           msi;
typedef multiset<long long>                                                     msll;
typedef set<long long, greater<long long> >                                     slld;
typedef set<int, greater<int> >                                                 sid;
typedef multiset<int, greater<int> >                                            msid;
typedef multiset<long long, greater<long long> >                                mslld;
typedef stack<long long>                                                        stll;
typedef stack<int>                                                              sti;
typedef queue<long long>                                                        qll;
typedef queue<int>                                                              qi;
typedef priority_queue<long long>                                               maxpqll;
typedef priority_queue<int>                                                     maxpqi;
typedef priority_queue<long long, vector<long long>, greater<long long> >       minpqll;
typedef priority_queue<int, vector<int>, greater<int> >                         minmpqi;
typedef priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> Minpairpq;

ll GCD(ll a, ll b){ll gcd, g;g = __gcd(a, b);return g;}
ll gcd(ll a, ll b){if(b == 0){return a;}else{return gcd(b, a%b);}}
ll extended_gcd(ll a, ll b, ll *x, ll *y){if(a == 0){*x = 0;*y = 1;return b;}ll x1, y1;ll d = extended_gcd(b%a, a, &x1, &y1);*x = y1-(b/a)*x1;*y = x1;return d;}
ll LCM(ll a, ll b){ll gcd, g;g = __gcd(a, b);return (a/g)*b;}
ll PowFun(ll base, ll power){ll ans = 1;for(int i = 1; i <= power; i++){ans *= base;}return ans;}
/*This is better power function here used binary exponentiation*/
ll MadeFun(ll b, ll p){if(p == 0){return 1;}else if(p%2 == 0){return MadeFun(b*b, p/2);}else{return b*MadeFun(b*b, (p-1)/2);}}
ll Set(ll n, ll pos){return n = n|(1<<pos);}
ll Reset(ll n, ll pos){return n = n& ~(1<<pos);}
bool Check(ll n, ll pos){return (bool)(n&(1<<pos));}

const ll INF_LONG = 1LL<<61;
const unsigned int inf_int = 1<<31;
const ll mod = 1e9+7;
double phi = acos(-1);

//own compare function structure for set
struct cmp_for_set_and_Semilar
{
    bool operator()(pair<int, int> a, pair<int, int> b)
    {
        return (a.first > b.first);
    }
};
//own compare function structure for vector pair
bool cmp(const pair<int, int> &a, const pair<int, int> &b)
{
    if(a.first != b.first)
    {
        return a.first < b.first;
    }
    return a.second > b.second;
}

long long BinaryEx(long long a, long long b)
{
    long long ans = 1;
    while(b)
    {
        if(b%2 == 0)
        {
            a = (a*a);
            b /= 2;
        }
        else
        {
            ans = (ans*a);
            b--;
        }
    }
    return ans;
}

long long mod_inverse(long long a)
{
    return BinaryEx(a, mod-2);
}

vector<pair<int, int>>vp;
int mark[3000005] = {1};
int index[3][3000005] = {};
int pos = 0;
int m = 0;
bool isSubsequence(string str1, string str2, int pos1, int pos2)
{
    //int m = str1.size();
    int n = str2.size();
    int j = pos1;
    int t1 = 0, t2 = 0;
    for(int i = pos2; i < n && j < m; i++)
    {
        if(str1[j] == str2[i] && j < m)
        {
            //j++;
            //vp.push_back(make_pair(j, i));
            pos++;
            index[0][pos] = j; index[1][pos] = i;
            //pos++;
            j++;
            //pos1 = j; pos2 = i;
            //t1 = j-1; t2 = i-1;
        }
    }
    //pos1 = t1; pos2 = t2;
    return (j == m);
}
void solve()
{
    string str; cin >> str;
    int n = str.size();
    cout << 3 << endl;
    cout << "R " << n-1 << endl;
    cout << "L " << n << endl;
    cout << "L " << 2 << endl;
}
int main()
{
    fastInputOutput();
    //int t; cin >> t;while(t--) solve();
    solve();
    return 0;
}


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

int main() {
	string s; cin >> s;
	cout << "R 1" << endl;
}


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

int main() {
	string s; cin >> s;
	int n = s.length();
	cout << 3 << endl;
	cout << "R " << n-1 << endl;
	cout << "L " << n-1 << endl;
	cout << "L 2" << endl;
}


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

int main() {
	string s; cin >> s;
	int n = s.length();
	cout << 3 << endl;
	cout << "R " << n-1 << endl;
	n += n-2;
	cout << "L " << n-1 << endl;
	cout << "L 2" << endl;
}


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

int main() {
	string s; cin >> s;
	cout << 1 << endl;
	cout << "R 1" << endl;
}


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

int main() {
	string s; cin >> s;
	cout << 1 << endl;
	cout << "R 2" << endl;
}


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

int main() {
	string s; cin >> s;
	int n = s.length();
	cout << 3 << endl;
	cout << "R " << n-1 << endl;
	cout << "L " << n << endl;
	cout << "L 2" << endl;
}


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

void Solve() {
	string s; cin >> s;
	cout << "L 1" << endl;
}

int main() {
	int t; cin >> t;
	while (t--) Solve();
}


#include <bits/stdc++.h>
using namespace std;
//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;
#define ll long long
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
vector <ll> v;
ll x,y,z,a,b,c,sum,ans,total,t,cnt,n,m,k,p,kase;
string s1,s2;
map<ll,ll> mp;
set<ll> s;
map<ll,ll> :: iterator itr1, ptr1;
set<ll> :: iterator itr, ptr;
void solve()
{
	ll x = 10;
	ll y = x*10;
	ll sqrt = x*y + x*y;
	bool flag = true;
	if(flag)
  	 x-=10;
	else
	 y-=10;
	y*=y;

ll pikachu = 10;

}
int main()
{

	cin>>s1;
	n = s1.size();
	cout<<5<<endl;
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n+= n-2;
	solve();
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	//clear vectors and maps you idiot
	// check array size dumb
	// use long long instead of int too
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;
#define ll long long
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
vector <ll> v;
ll x,y,z,a,b,c,sum,ans,total,t,cnt,n,m,k,p,kase;
string s1,s2;
map<ll,ll> mp;
set<ll> s;
map<ll,ll> :: iterator itr1, ptr1;
set<ll> :: iterator itr, ptr;
void solve()
{
	ll x = 10;
	ll y = x*10;
	ll sqrt = x*y + x*y;
	bool flag = true;
	if(flag)
  	 x-=10;
	else
	 y-=10;
	y*=y;

ll pikachu = 10;

}
int main()
{

	cin>>s1;
	n = s1.size();
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n+= n-2;
	solve();
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	//clear vectors and maps you idiot
	// check array size dumb
	// use long long instead of int too
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;
#define ll long long
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
vector <ll> v;
ll x,y,z,a,b,c,sum,ans,total,t,cnt,n,m,k,p,kase;
string s1,s2;
map<ll,ll> mp;
set<ll> s;
map<ll,ll> :: iterator itr1, ptr1;
set<ll> :: iterator itr, ptr;
void solve()
{
	ll x = 10;
	ll y = x*10;
	ll sqrt = x*y + x*y;
	bool flag = true;
	if(flag)
  	 x-=10;
	else
	 y-=10;
	y*=y;

ll pikachu = 10;

}
int main()
{

	cin>>s1;
	n = s1.size();
	cout<<5<<endl;
	cout<<"L"<<" "<<2<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<2<<endl;
	n+=(n-2);
	solve();
	cout<<"L"<<" "<<2<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	//clear vectors and maps you idiot
	// check array size dumb
	// use long long instead of int too
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;
#define ll long long
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
vector <ll> v;
ll x,y,z,a,b,c,sum,ans,total,t,cnt,n,m,k,p,kase;
string s1,s2;
map<ll,ll> mp;
set<ll> s;
map<ll,ll> :: iterator itr1, ptr1;
set<ll> :: iterator itr, ptr;
void solve()
{
	ll x = 10;
	ll y = x*10;
	ll sqrt = x*y + x*y;
	bool flag = true;
	if(flag)
  	 x-=10;
	else
	 y-=10;
	y*=y;

ll pikachu = 10;

}
int main()
{

	cin>>s1;
	n = s1.size();
	cout<<5<<endl;
	cout<<"L"<<" "<<2<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n+= n-2;
	solve();
	cout<<"L"<<" "<<2<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	//clear vectors and maps you idiot
	// check array size dumb
	// use long long instead of int too
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;
#define ll long long
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
vector <ll> v;
ll x,y,z,a,b,c,sum,ans,total,t,cnt,n,m,k,p,kase;
string s1,s2;
map<ll,ll> mp;
set<ll> s;
map<ll,ll> :: iterator itr1, ptr1;
set<ll> :: iterator itr, ptr;
void solve()
{
	ll x = 10;
	ll y = x*10;
	ll sqrt = x*y + x*y;
	bool flag = true;
	if(flag)
  	 x-=10;
	else
	 y-=10;
	y*=y;

ll pikachu = 10;

}
int main()
{

	cin>>s1;
	n = s1.size()-1;
	cout<<5<<endl;
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n+= (n-1);
	solve();
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-1<<endl;
	n++;
	solve();
	//clear vectors and maps you idiot
	// check array size dumb
	// use long long instead of int too
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
//SET PRECIOSION   cout << fixed ;  cout << setprecision(n) << ans << endl;
#define ll long long
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
vector <ll> v;
ll x,y,z,a,b,c,sum,ans,total,t,cnt,n,m,k,p,kase;
string s1,s2;
map<ll,ll> mp;
set<ll> s;
map<ll,ll> :: iterator itr1, ptr1;
set<ll> :: iterator itr, ptr;
void solve()
{
	ll x = 10;
	ll y = x*10;
	ll sqrt = x*y + x*y;
	bool flag = true;
	if(flag)
  	 x-=10;
	else
	 y-=10;
	y*=y;

ll pikachu = 10;

}
int main()
{

	cin>>s1;
	n = s1.size();
	cout<<5<<endl;
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-2<<endl;
	n+= n-2;
	solve();
	cout<<"L"<<" "<<1<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-2<<endl;
	n++;
	solve();
	cout<<"R"<<" "<<n-2<<endl;
	n++;
	solve();
	//clear vectors and maps you idiot
	// check array size dumb
	// use long long instead of int too
	return 0;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {

}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
    read(T);
    while (T--)
        solve();
    __timeEnd;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {
    string s;
    cin >> s;
    int n = s.length();
    cout<<3<<endl;
    cout<<"R "<<n-1<<endl;
    cout<<"L "<<n<<endl;
    cout<<"L "<<2<<endl;
}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
//    read(T);
//    while (T--)
        solve();
    __timeEnd;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {
    string s;
    cin >> s;
    int n = s.length();
    cout<<3<<endl;
    cout<<"L "<<2<<endl;
    cout<<"R "<<2<<endl;
    cout<<"R "<<n-1<<endl;
}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
//    read(T);
//    while (T--)
        solve();
    __timeEnd;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {
    string s;
    cin >> s;
    int n = s.length();
    cout<<3<<endl;
    cout<<"R "<<n-1<<endl;
    cout<<"R "<<n<<endl;
    cout<<"L "<<2<<endl;
}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
    read(T);
    while (T--)
        solve();
    __timeEnd;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {
    int n = 0;
    while (getchar())
        n++;
    cout << 3 << endl;
    cout << "R " << n - 1 << endl;
    cout << "L " << n << endl;
    cout << "L " << 2 << endl;
}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
//    read(T);
//    while (T--)
    solve();
    __timeEnd;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {
    int n = 0;
    while (getchar_unlocked())
        n++;
    cout << 3 << endl;
    cout << "R " << n - 1 << endl;
    cout << "L " << n << endl;
    cout << "L " << 2 << endl;
}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
//    read(T);
//    while (T--)
    solve();
    __timeEnd;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {
    string s;
    cin >> s;
    int n = s.length();
    cout<<3<<endl;
    cout<<"R "<<n-1<<endl;
    cout<<"R "<<n<<endl;
    cout<<"L "<<2<<endl;
}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
//    read(T);
//    while (T--)
        solve();
    __timeEnd;
}


/*/---------------------------imports----------------------/*/
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

using namespace __gnu_pbds;
using namespace std;
/*/---------------------------imports----------------------/*/

/*/---------------------------macros----------------------/*/
#define int long long
#define endl '\n'
#define MOD 1000000007
#define isOdd(x) ((x)&1)
#define isEven(x) (!((x)&1))
#define all(x) (x).begin(), (x).end()
#define read(...)    \
    int __VA_ARGS__; \
    __read(__VA_ARGS__)
#define TT template <typename T>
#define LR template <typename L, typename R>
#define TV template <typename T, typename... V>
#ifndef ONLINE_JUDGE
#define deb(...) cerr << "L(" << __LINE__ << ")*[" << #__VA_ARGS__ << "]: [", __write(__VA_ARGS__)
#else
#define deb(...)
#endif
#define __timeStart auto __start_time = chrono::high_resolution_clock::now()
#define __timeEnd                                                                                \
    auto __stop_time = std::chrono::high_resolution_clock::now();                                       \
    auto __duration = std::chrono::duration_cast<std::chrono::nanoseconds>(__stop_time - __start_time); \
    cerr << "Time taken : " << ((long double)__duration.count()) / ((long double)1e9) << "s " << endl

/*/---------------------------macros----------------------/*/

/*/---------------------------STL overloaded I/O----------------------/*/
TT istream &operator>>(istream &is, vector<T> &V);

TT ostream &operator<<(ostream &os, const vector<T> &V);

TT ostream &operator<<(ostream &os, const unordered_set<T> &S);

TT ostream &operator<<(ostream &os, const multiset<T> &S);

TT ostream &operator<<(ostream &os, const set<T> &S);

LR ostream &operator<<(ostream &os, const pair<L, R> &P);

LR ostream &operator<<(ostream &os, const map<L, R> &M);

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M);

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, array<T, arrSize> &A);

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A);

TT istream &operator>>(istream &is, vector<T> &V) {
    for (auto &e : V)
        is >> e;
    return is;
}

TT ostream &operator<<(ostream &os, const vector<T> &V) {
    os << "[ ";
    for (auto &v : V)
        os << v << " ";
    return os << "]";
}

TT ostream &operator<<(ostream &os, const unordered_set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const multiset<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

TT ostream &operator<<(ostream &os, const set<T> &S) {
    os << "{ ";
    for (auto &s : S)
        os << s << " ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const pair<L, R> &P) {
    return os << "(" << P.first << "," << P.second << ")";
}

LR ostream &operator<<(ostream &os, const map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

LR ostream &operator<<(ostream &os, const unordered_map<L, R> &M) {
    os << "{ ";
    for (auto &m : M)
        os << "(" << m.first << ":" << m.second << ") ";
    return os << "}";
}

template<typename T, size_t arrSize>
ostream &operator<<(ostream &os, const array<T, arrSize> &A) {
    os << "[ ";
    for (auto &a : A)
        os << a << " ";
    return os << "]";
}

template<typename T, size_t arrSize>
istream &operator<<(istream &is, array<T, arrSize> &A) {
    for (auto &a : A)
        is >> a;
    return is;
}
/*/---------------------------STL overloaded I/O----------------------/*/

/*/---------------------------I/O Ports----------------------/*/
void __write() {
    cerr << "]\n";
}

TV void __write(const T &t, const V &... v) {
    cerr << t;
    if (sizeof...(v))
        cerr << ", ";
    __write(v...);
}

TT void __read(T &x) {
    cin >> x;
}

TV void __read(T &t, V &... v) {
    __read(t);
    __read(v...);
}
/*/---------------------------I/O Ports----------------------/*/

/*/---------------------------myFunctions----------------------/*/
int power(int x, int y) {
    int res = 1;
    while (y)
        res = !(y & 1) ?: res * x, y >>= 1, x *= x;
    return res;
}

mt19937_64 __MT19337GEN__(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random(int l, int r) {
    uniform_int_distribution<int> generator(l, r);
    return generator(__MT19337GEN__);
}

inline int64_t random() {
    uniform_int_distribution<int> generator(LLONG_MIN, LLONG_MAX);
    return generator(__MT19337GEN__);
}
/*/---------------------------myFunctions----------------------/*/

/*/---------------------------startCoding----------------------/*/

void solve() {
    string s;
    cin >> s;
    int n = s.length();
    cout<<3<<endl;
    cout<<"L "<<2<<endl;
    cout<<"R "<<2<<endl;
    cout<<"R "<<n+n-1<<endl;
}

signed main() {
    ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
    cout << fixed << setprecision(25), cerr << fixed << setprecision(10);
    __timeStart;
//    read(T);
//    while (T--)
        solve();
    __timeEnd;
}

/*/---------------------------uWu----------------------/*/


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

#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL);}
#define f first
#define s second
#define getunique(v) {sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());}
typedef long long ll;
typedef long double lld;
typedef unsigned long long ull;

template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
	cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
	cin >> p.first;
	return cin >> p.second;
}

mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 rng(61378913);
/* usage - just do rng() */

void usaco(string filename) {
  // #pragma message("be careful, freopen may be wrong")
	freopen((filename + ".in").c_str(), "r", stdin);
	freopen((filename + ".out").c_str(), "w", stdout);
}

// #include <atcoder/all>
// using namespace atcoder;

const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
// ll mod;

ll n, m, k, q, l, r, x, y, z;
const ll template_array_size = 1e6 + 5021;
ll a[template_array_size];
ll b[template_array_size];
ll c[template_array_size];
string s, t;
ll ans = 0;

void solve(int tc = 0) {
	cin >> s; n = s.length();
	cout << "8\n";
	for (ll i = 0; i < 3; i++) cout << "R " << n + i - 2 << '\n';
	cout << "L 2\nL 2\nL 2\nR 2\n";
	cout << "R " << 2 << '\n';
	cout << "R " << 2 * n + 8 << '\n';
}

int main() {
	#ifdef galen_colin_local
		auto begin = std::chrono::high_resolution_clock::now();
	#endif

	send help

	#ifndef galen_colin_local
		// usaco("cowpatibility");
	#endif

	// usaco("cowland");

	// freopen("tc.cpp", "r", stdin);

	int tc = 1;
	// cin >> tc;
	for (int t = 0; t < tc; t++) solve(t);

	#ifdef galen_colin_local
		auto end = std::chrono::high_resolution_clock::now();
		cout << setprecision(4) << fixed;
		// cout << "Execution time: " << std::chrono::duration_cast<std::chrono::duration<double>>(end - begin).count() << " seconds" << endl;
	#endif
}


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

#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL);}
#define f first
#define s second
#define getunique(v) {sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());}
typedef long long ll;
typedef long double lld;
typedef unsigned long long ull;

template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
	cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
	cin >> p.first;
	return cin >> p.second;
}

mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 rng(61378913);
/* usage - just do rng() */

void usaco(string filename) {
  // #pragma message("be careful, freopen may be wrong")
	freopen((filename + ".in").c_str(), "r", stdin);
	freopen((filename + ".out").c_str(), "w", stdout);
}

// #include <atcoder/all>
// using namespace atcoder;

const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
// ll mod;

ll n, m, k, q, l, r, x, y, z;
const ll template_array_size = 1e6 + 5021;
ll a[template_array_size];
ll b[template_array_size];
ll c[template_array_size];
string s, t;
ll ans = 0;

void solve(int tc = 0) {
	cin >> s; n = s.length();
	cout << "3\n";
	cout << "L " << 2 << '\n';
	cout << "R " << 2 << '\n';
	cout << "R " << 2 * n - 2 << '\n';
}

int main() {
	#ifdef galen_colin_local
		auto begin = std::chrono::high_resolution_clock::now();
	#endif

	send help

	#ifndef galen_colin_local
		// usaco("cowpatibility");
	#endif

	// usaco("cowland");

	// freopen("tc.cpp", "r", stdin);

	int tc = 1;
	// cin >> tc;
	for (int t = 0; t < tc; t++) solve(t);

	#ifdef galen_colin_local
		auto end = std::chrono::high_resolution_clock::now();
		cout << setprecision(4) << fixed;
		// cout << "Execution time: " << std::chrono::duration_cast<std::chrono::duration<double>>(end - begin).count() << " seconds" << endl;
	#endif
}


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

#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL);}
#define f first
#define s second
#define getunique(v) {sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());}
typedef long long ll;
typedef long double lld;
typedef unsigned long long ull;

template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
	cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
	cin >> p.first;
	return cin >> p.second;
}

mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 rng(61378913);
/* usage - just do rng() */

void usaco(string filename) {
  // #pragma message("be careful, freopen may be wrong")
	freopen((filename + ".in").c_str(), "r", stdin);
	freopen((filename + ".out").c_str(), "w", stdout);
}

// #include <atcoder/all>
// using namespace atcoder;

const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
// ll mod;

ll n, m, k, q, l, r, x, y, z;
const ll template_array_size = 1e6 + 5021;
ll a[template_array_size];
ll b[template_array_size];
ll c[template_array_size];
string s, t;
ll ans = 0;

void solve(int tc = 0) {
	cin >> s; n = s.length();
	cout << "3\n";
	cout << "L " << 2 << '\n';
	cout << "R " << 2 << '\n';
	cout << "R " << 2 * n - 1 << '\n';
}

int main() {
	#ifdef galen_colin_local
		auto begin = std::chrono::high_resolution_clock::now();
	#endif

	send help

	#ifndef galen_colin_local
		// usaco("cowpatibility");
	#endif

	// usaco("cowland");

	// freopen("tc.cpp", "r", stdin);

	int tc = 1;
	// cin >> tc;
	for (int t = 0; t < tc; t++) solve(t);

	#ifdef galen_colin_local
		auto end = std::chrono::high_resolution_clock::now();
		cout << setprecision(4) << fixed;
		// cout << "Execution time: " << std::chrono::duration_cast<std::chrono::duration<double>>(end - begin).count() << " seconds" << endl;
	#endif
}


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

#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL);}
#define f first
#define s second
#define getunique(v) {sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());}
typedef long long ll;
typedef long double lld;
typedef unsigned long long ull;

template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
	cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
	cin >> p.first;
	return cin >> p.second;
}

mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 rng(61378913);
/* usage - just do rng() */

void usaco(string filename) {
  // #pragma message("be careful, freopen may be wrong")
	freopen((filename + ".in").c_str(), "r", stdin);
	freopen((filename + ".out").c_str(), "w", stdout);
}

// #include <atcoder/all>
// using namespace atcoder;

const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
// ll mod;

ll n, m, k, q, l, r, x, y, z;
const ll template_array_size = 1e6 + 5021;
ll a[template_array_size];
ll b[template_array_size];
ll c[template_array_size];
string s, t;
ll ans = 0;

void solve(int tc = 0) {
	cout << "8\n";
	for (ll i = 0; i < 3; i++) cout << "R " << n + i - 2 << '\n';
	cout << "L 2\nL 2\nL 2\nR 2";
	cout << "R " << 2 << '\n';
	cout << "R " << 2 * n + 8 << '\n';
}

int main() {
	#ifdef galen_colin_local
		auto begin = std::chrono::high_resolution_clock::now();
	#endif

	send help

	#ifndef galen_colin_local
		// usaco("cowpatibility");
	#endif

	// usaco("cowland");

	// freopen("tc.cpp", "r", stdin);

	int tc = 1;
	// cin >> tc;
	for (int t = 0; t < tc; t++) solve(t);

	#ifdef galen_colin_local
		auto end = std::chrono::high_resolution_clock::now();
		cout << setprecision(4) << fixed;
		// cout << "Execution time: " << std::chrono::duration_cast<std::chrono::duration<double>>(end - begin).count() << " seconds" << endl;
	#endif
}


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

#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL);}
#define f first
#define s second
#define getunique(v) {sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());}
typedef long long ll;
typedef long double lld;
typedef unsigned long long ull;

template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
	cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
	cin >> p.first;
	return cin >> p.second;
}

mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 rng(61378913);
/* usage - just do rng() */

void usaco(string filename) {
  // #pragma message("be careful, freopen may be wrong")
	freopen((filename + ".in").c_str(), "r", stdin);
	freopen((filename + ".out").c_str(), "w", stdout);
}

// #include <atcoder/all>
// using namespace atcoder;

const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
// ll mod;

ll n, m, k, q, l, r, x, y, z;
const ll template_array_size = 1e6 + 5021;
ll a[template_array_size];
ll b[template_array_size];
ll c[template_array_size];
string s, t;
ll ans = 0;

void solve(int tc = 0) {
	cin >> n;
	cout << "8\n";
	for (ll i = 0; i < 3; i++) cout << "R " << n + i - 2 << '\n';
	cout << "L 2\nL 2\nL 2\nR 2";
	cout << "R " << 2 << '\n';
	cout << "R " << 2 * n + 8 << '\n';
}

int main() {
	#ifdef galen_colin_local
		auto begin = std::chrono::high_resolution_clock::now();
	#endif

	send help

	#ifndef galen_colin_local
		// usaco("cowpatibility");
	#endif

	// usaco("cowland");

	// freopen("tc.cpp", "r", stdin);

	int tc = 1;
	// cin >> tc;
	for (int t = 0; t < tc; t++) solve(t);

	#ifdef galen_colin_local
		auto end = std::chrono::high_resolution_clock::now();
		cout << setprecision(4) << fixed;
		// cout << "Execution time: " << std::chrono::duration_cast<std::chrono::duration<double>>(end - begin).count() << " seconds" << endl;
	#endif
}


#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define endl '\n'
#define maxl __LONG_LONG_MAX__
#define pb push_back
#define F first
#define S second
#define rep(i, n) for(int i = 0; i < n; i++)
#define rev(i, n) for(int i = n-1; i >= 0; i--)
#define rep1(i, n) for(int i=1; i < n; i++)
#define rev1(i, n) for(int i=n ; i > 0; i--)
#define n_ones(x) __builtin_popcountll(x)
#define n_trailzero(x) __builtin_ctzll(x)
#define n_leadingzero(x) __builtin_clz(x)
#define sz(a) (ll)(a.size())
#define all(v) v.begin(),v.end()
#define FASTIO {ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);}
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a/gcd(a, b))*b
#define PI 3.14159265358979323846
#define see(args...)                       \
{                                            \
    cerr<<"LINE "<<__LINE__;                 \
    string _s = #args;                       \
    replace(_s.begin(), _s.end(), ',', ' '); \
    stringstream _ss(_s);                    \
    istream_iterator<string> _it(_ss);       \
    err(_it, args);                          \
    cerr<<endl;                              \
}
void err(istream_iterator<string> it){}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args)
{
  cerr<<' '<< *it << " = " << a ;
  err(++it, args...);
}
template <typename T, typename U>inline void min_self(T &x, U y){if (y < x)x = y;}
template <typename T, typename U>inline void max_self(T &x, U y){if (x < y)x = y;}
template<class T1, class T2>ostream& operator<< (ostream &out, pair<T1, T2> pair) { return out << "(" << pair.first << ", " << pair.second << ")";}
template<class T> ostream& operator<<(ostream& out, vector<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class T> ostream& operator<<(ostream& out, set<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class L, class R> ostream& operator<<(ostream& out, map<L, R> vec) { out<<"("; for (auto& v: vec) out<<"["<<v.first<<", "<<v.second<<"]"; return out<<")"; }
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}

typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<pair<ll, ll> > vpll;
typedef vector<vector<ll> > vvll;

// typedef tree<int,null_type,less<int>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setll;
// typedef tree<char,null_type,less<char>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setc;

ll max(int a,ll b){ return max((ll)a,b);}
ll min(int a,ll b){ return min((ll)a,b);}
ll min(ll a,int b){ return min(a,(ll)b);}
ll max(ll a,int b){ return max(a,(ll)b);}

// cout<<fixed<<setprecision(20)<<pi<<endl;

ll mod = 1e9 + 7;
ll Test, cas;

void solve()
{
	string s;
	cin>>s;
	cout<<3<<endl;
	cout<<"L"<<" "<<2<<endl;
	cout<<"R"<<" "<<n<<endl;
	cout<<"R"<<" "<<(2*n-1)<<endl;
	return;
}

int main()
{
	FASTIO;
	Test = 1;
	//cin>>Test;
	for(cas = 1; cas <= Test; cas++)
		solve();
	return 0;
}


#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define endl '\n'
#define maxl __LONG_LONG_MAX__
#define pb push_back
#define F first
#define S second
#define rep(i, n) for(int i = 0; i < n; i++)
#define rev(i, n) for(int i = n-1; i >= 0; i--)
#define rep1(i, n) for(int i=1; i < n; i++)
#define rev1(i, n) for(int i=n ; i > 0; i--)
#define n_ones(x) __builtin_popcountll(x)
#define n_trailzero(x) __builtin_ctzll(x)
#define n_leadingzero(x) __builtin_clz(x)
#define sz(a) (ll)(a.size())
#define all(v) v.begin(),v.end()
#define FASTIO {ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);}
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a/gcd(a, b))*b
#define PI 3.14159265358979323846
#define see(args...)                       \
{                                            \
    cerr<<"LINE "<<__LINE__;                 \
    string _s = #args;                       \
    replace(_s.begin(), _s.end(), ',', ' '); \
    stringstream _ss(_s);                    \
    istream_iterator<string> _it(_ss);       \
    err(_it, args);                          \
    cerr<<endl;                              \
}
void err(istream_iterator<string> it){}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args)
{
  cerr<<' '<< *it << " = " << a ;
  err(++it, args...);
}
template <typename T, typename U>inline void min_self(T &x, U y){if (y < x)x = y;}
template <typename T, typename U>inline void max_self(T &x, U y){if (x < y)x = y;}
template<class T1, class T2>ostream& operator<< (ostream &out, pair<T1, T2> pair) { return out << "(" << pair.first << ", " << pair.second << ")";}
template<class T> ostream& operator<<(ostream& out, vector<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class T> ostream& operator<<(ostream& out, set<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class L, class R> ostream& operator<<(ostream& out, map<L, R> vec) { out<<"("; for (auto& v: vec) out<<"["<<v.first<<", "<<v.second<<"]"; return out<<")"; }
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}

typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<pair<ll, ll> > vpll;
typedef vector<vector<ll> > vvll;

// typedef tree<int,null_type,less<int>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setll;
// typedef tree<char,null_type,less<char>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setc;

ll max(int a,ll b){ return max((ll)a,b);}
ll min(int a,ll b){ return min((ll)a,b);}
ll min(ll a,int b){ return min(a,(ll)b);}
ll max(ll a,int b){ return max(a,(ll)b);}

// cout<<fixed<<setprecision(20)<<pi<<endl;

ll mod = 1e9 + 7;
ll Test, cas;

void solve()
{
	string s;
	cin>>s;
	ll n = sz(s);
	cout<<3<<endl;
	cout<<"L"<<" "<<2<<endl;
	cout<<"R"<<" "<<2<<endl;
	cout<<"R"<<" "<<(2*n-1)<<endl;
	return;
}

int main()
{
	FASTIO;
	Test = 1;
	//cin>>Test;
	for(cas = 1; cas <= Test; cas++)
		solve();
	return 0;
}


#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define endl '\n'
#define maxl __LONG_LONG_MAX__
#define pb push_back
#define F first
#define S second
#define rep(i, n) for(int i = 0; i < n; i++)
#define rev(i, n) for(int i = n-1; i >= 0; i--)
#define rep1(i, n) for(int i=1; i < n; i++)
#define rev1(i, n) for(int i=n ; i > 0; i--)
#define n_ones(x) __builtin_popcountll(x)
#define n_trailzero(x) __builtin_ctzll(x)
#define n_leadingzero(x) __builtin_clz(x)
#define sz(a) (ll)(a.size())
#define all(v) v.begin(),v.end()
#define FASTIO {ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);}
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a/gcd(a, b))*b
#define PI 3.14159265358979323846
#define see(args...)                       \
{                                            \
    cerr<<"LINE "<<__LINE__;                 \
    string _s = #args;                       \
    replace(_s.begin(), _s.end(), ',', ' '); \
    stringstream _ss(_s);                    \
    istream_iterator<string> _it(_ss);       \
    err(_it, args);                          \
    cerr<<endl;                              \
}
void err(istream_iterator<string> it){}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args)
{
  cerr<<' '<< *it << " = " << a ;
  err(++it, args...);
}
template <typename T, typename U>inline void min_self(T &x, U y){if (y < x)x = y;}
template <typename T, typename U>inline void max_self(T &x, U y){if (x < y)x = y;}
template<class T1, class T2>ostream& operator<< (ostream &out, pair<T1, T2> pair) { return out << "(" << pair.first << ", " << pair.second << ")";}
template<class T> ostream& operator<<(ostream& out, vector<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class T> ostream& operator<<(ostream& out, set<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class L, class R> ostream& operator<<(ostream& out, map<L, R> vec) { out<<"("; for (auto& v: vec) out<<"["<<v.first<<", "<<v.second<<"]"; return out<<")"; }
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}

typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<pair<ll, ll> > vpll;
typedef vector<vector<ll> > vvll;

// typedef tree<int,null_type,less<int>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setll;
// typedef tree<char,null_type,less<char>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setc;

ll max(int a,ll b){ return max((ll)a,b);}
ll min(int a,ll b){ return min((ll)a,b);}
ll min(ll a,int b){ return min(a,(ll)b);}
ll max(ll a,int b){ return max(a,(ll)b);}

// cout<<fixed<<setprecision(20)<<pi<<endl;

ll mod = 1e9 + 7;
ll Test, cas;

void solve()
{
	string s;
	cin>>s;
	cout<<"L"<<" "<<sz(s)<<endl;
	return;
}

int main()
{
	FASTIO;
	Test = 1;
	//cin>>Test;
	for(cas = 1; cas <= Test; cas++)
		solve();
	return 0;
}


#include<bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define endl '\n'
#define maxl __LONG_LONG_MAX__
#define pb push_back
#define F first
#define S second
#define rep(i, n) for(int i = 0; i < n; i++)
#define rev(i, n) for(int i = n-1; i >= 0; i--)
#define rep1(i, n) for(int i=1; i < n; i++)
#define rev1(i, n) for(int i=n ; i > 0; i--)
#define n_ones(x) __builtin_popcountll(x)
#define n_trailzero(x) __builtin_ctzll(x)
#define n_leadingzero(x) __builtin_clz(x)
#define sz(a) (ll)(a.size())
#define all(v) v.begin(),v.end()
#define FASTIO {ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);}
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) (a/gcd(a, b))*b
#define PI 3.14159265358979323846
#define see(args...)                       \
{                                            \
    cerr<<"LINE "<<__LINE__;                 \
    string _s = #args;                       \
    replace(_s.begin(), _s.end(), ',', ' '); \
    stringstream _ss(_s);                    \
    istream_iterator<string> _it(_ss);       \
    err(_it, args);                          \
    cerr<<endl;                              \
}
void err(istream_iterator<string> it){}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args)
{
  cerr<<' '<< *it << " = " << a ;
  err(++it, args...);
}
template <typename T, typename U>inline void min_self(T &x, U y){if (y < x)x = y;}
template <typename T, typename U>inline void max_self(T &x, U y){if (x < y)x = y;}
template<class T1, class T2>ostream& operator<< (ostream &out, pair<T1, T2> pair) { return out << "(" << pair.first << ", " << pair.second << ")";}
template<class T> ostream& operator<<(ostream& out, vector<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class T> ostream& operator<<(ostream& out, set<T> vec) { out<<"("; for (auto& v: vec) out<<v<<", "; return out<<")"; }
template<class L, class R> ostream& operator<<(ostream& out, map<L, R> vec) { out<<"("; for (auto& v: vec) out<<"["<<v.first<<", "<<v.second<<"]"; return out<<")"; }
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}

typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<pair<ll, ll> > vpll;
typedef vector<vector<ll> > vvll;

// typedef tree<int,null_type,less<int>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setll;
// typedef tree<char,null_type,less<char>,rb_tree_tag,
// tree_order_statistics_node_update> indexed_setc;

ll max(int a,ll b){ return max((ll)a,b);}
ll min(int a,ll b){ return min((ll)a,b);}
ll min(ll a,int b){ return min(a,(ll)b);}
ll max(ll a,int b){ return max(a,(ll)b);}

// cout<<fixed<<setprecision(20)<<pi<<endl;

ll mod = 1e9 + 7;
ll Test, cas;

void solve()
{
	string s;
	cin>>s;
	ll n = sz(s);
	cout<<3<<endl;
	cout<<"L"<<" "<<2<<endl;
	cout<<"R"<<" "<<n-1<<endl;
	cout<<"R"<<" "<<n-1<<endl;
	return;
}

int main()
{
	FASTIO;
	Test = 1;
	//cin>>Test;
	for(cas = 1; cas <= Test; cas++)
		solve();
	return 0;
}