Problem: This is an output-only problem. You shouldn't read anything from the input.

In short, your task is to simulate multiplication by using only comparison (x < y) and addition (x + y). There is no input in this problem, you just print a sequence of operations.

Imagine that there is a big array a[0], a[1], ..., a[N-1] of length N. The first two values are initially two non-negative integers A and B (which are unknown to you), the other elements are zeros. Your goal is to get the product A \cdot B in a[2] at the end.

You are allowed operations of two types, with the following format (where 0 \leq i, j, k < N):

* `+ i j k` — applies operation a[k] = a[i] + a[j].
* `< i j k` — applies operation a[k] = a[i] < a[j]. That is, if a[i] < a[j] then a[k] becomes 1, otherwise it becomes 0.



You can use at most Q operations. Elements of a can't exceed V. Indices (i, j, k) don't have to be distinct. It's allowed to modify any element of the array (including the first two). The actual checker simulates the process for multiple pairs (A, B) within a single test. Each time, the checker chooses values A and B, creates the array a = [A, B, 0, 0, \ldots, 0], applies all your operations and ensures that a[2] = A \cdot B.

Constraints

* 0 \leq A, B \leq 10^9
* N = Q = 200\,000
* V = 10^{19} = 10\,000\,000\,000\,000\,000\,000

Input

The Standard Input is empty.

Output

In the first line, print the number of operations. Each operation should then be printed in a single line of format `+ i j k` or `< i j k`.

Example

Input




Output

Solution (in CPP):

Solution:
#include <cstdio>
#include <cctype>
#include <vector>
#include <algorithm>
#define FILENAME(x) \
freopen(x".in","r",stdin); \
freopen(x".out","w",stdout);
#define MAXIOLG 25
#define LOWBIT(x) ((x)&(-(x)))
#define MOD 998244353
#define MD(x) (((x)>=MOD)?((x)-=MOD):(0))
#define OPS "?+<?"
#define N 299
#define MXLG 60
using namespace std;

typedef long long ll;
typedef ll io_t;

io_t shin[MAXIOLG];
io_t seto(void);
void ayano(io_t x,char spliter='\n');

struct Ene{
    int op,x,y,z;
    Ene(void):op(0),x(0),y(0),z(0){}
    Ene(int tp,int tx,int ty,int tz):op(tp),x(tx),y(ty),z(tz){}
    Ene(const Ene& tc):op(tc.op),x(tc.x),y(tc.y),z(tc.z){}
};

vector<Ene> vec;

void make_pw(void);
void sub(int x,int y,int z,int k);
void to_bin(int x,int l,int k);
void to_dec(int x,int l,int k);
void mult(int l1,int l2,int l3,int k);
void lmv(int x,int k);
void land(int x,int y,int z);
void add(int x,int y,int z);
void les(int x,int y,int z);

int main(void){
    make_pw();
    to_bin(0,30,30);
    to_bin(1,70,30);
    mult(30,70,110,30);
    to_dec(2,110,60);
    //vec.push_back(Ene());
    ayano(vec.size());
    for (auto v:vec){
        putchar(OPS[v.op]),putchar(' '),
        ayano(v.x,' '),ayano(v.y,' '),ayano(v.z);
    }
    return 0;
}

void sub(int x,int y,int z,int k){
    add(y,3,16); //arr[16]=0+arr[y];
    for (int tlg=k;tlg>=0;tlg--){
        add(16,N-tlg,17); //arr[17]=arr[16]+(1<<tlg);
        les(17,x,18); //arr[18]=(arr[17]<arr[x]);
        lmv(18,tlg);
        add(z,18,z); //arr[z]=arr[18]+arr[z];
        add(16,18,16); //arr[16]=arr[18]+arr[16];
    }
    les(y,x,18);
    add(z,18,z); //arr[z]=arr[z]+(arr[y]<arr[x]);
}
void mult(int l1,int l2,int l3,int k){
    for (int i=0;i<=k;i++){
        for (int j=0;j<=k;j++){
            int res=i+j;
            land(l1+i,l2+j,14);
            add(14,l3+res,l3+res);
        }
    }
}
void to_dec(int x,int l,int k){
    for (int i=0;i<=k;i++){
        add(3,l+i,15); //arr[15]=0+arr[l+i];
        lmv(15,i);
        add(x,15,x); //arr[x]=arr[x]+arr[15];
    }
}
void to_bin(int x,int l,int k){
    add(x,N,13); //arr[13]=1+arr[x];
    add(3,3,11); //arr[11]=0+0;
    //Position 11 saves the certain sum
    //Position 12 is used to try
    //Position 13 saves arr[x]+1
    for (int tlg=k;tlg>=0;tlg--){
        add(N-tlg,11,12); //arr[12]=arr[11]+(1<<k);
        les(12,13,12); //arr[12]=(arr[12]<arr[13]);
        add(12,3,l+tlg); //arr[l+tlg]=arr[12]+0;
        lmv(12,tlg);
        add(11,12,11); //arr[11]=arr[11]+arr[12];
    }
}
void make_pw(void){
    add(0,1,N);
    les(3,N,N);
    for (int i=1;i<=MXLG;i++)
        add(N-i+1,N-i+1,N-i);
}
void lmv(int x,int k){
    while (k--)
        add(x,x,x);
}
void land(int x,int y,int z){
    add(x,y,4);
    les(N,4,z);
}
void add(int x,int y,int z){
    vec.push_back(Ene(1,x,y,z));
}
void les(int x,int y,int z){
    vec.push_back(Ene(2,x,y,z));
}

io_t seto(void){
    io_t x=0;
    char ch=getchar();
    int symbol=0;
    while (!isdigit(ch))
        (ch=='-')?(symbol=1):(0),
        ch=getchar();
    while (isdigit(ch))
        x=(x*10)+(ch-'0'),
        ch=getchar();
    return (symbol)?(-x):(x);
}
void ayano(io_t x,char spliter){
    if (!x){
        putchar('0'),putchar(spliter);
        return;
    }
    if (x<0)
        putchar('-'),x=-x;
    int ren=0;
    while (x){
        io_t d=x/10;
        shin[ren++]=x-d*10;
        x=d;
    }
    while (ren--)
        putchar(shin[ren]+'0');
    putchar(spliter);
}