import std.conv, std.functional, std.range, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.bitmanip, std.complex, std.container, std.math, std.mathspecial, std.numeric, std.regex, std.typecons;
import core.bitop;

class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
string readToken() { for (; tokens.empty; ) { if (stdin.eof) { throw new EOFException; } tokens = readln.split; } auto token = tokens.front; tokens.popFront; return token; }
int readInt() { return readToken.to!int; }
long readLong() { return readToken.to!long; }
real readReal() { return readToken.to!real; }

bool chmin(T)(ref T t, in T f) { if (t > f) { t = f; return true; } else { return false; } }
bool chmax(T)(ref T t, in T f) { if (t < f) { t = f; return true; } else { return false; } }

int binarySearch(alias pred, T)(in T[] as) { int lo = -1, hi = cast(int)(as.length); for (; lo + 1 < hi; ) { const mid = (lo + hi) >> 1; (unaryFun!pred(as[mid]) ? hi : lo) = mid; } return hi; }
int lowerBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a >= val)); }
int upperBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a > val)); }


enum LEN = 300;
enum E = 30;

int[][] program;

void add(int i, int j, int k) {
  program ~= [0, i, j, k];
}
void cmp(int i, int j, int k) {
  program ~= [1, i, j, k];
}

void test(long a, long b) {
  auto xs = new long[LEN];
  xs[0] = a;
  xs[1] = b;
  foreach (line; program) {
    const op = line[0];
    const i = line[1];
    const j = line[2];
    const k = line[3];
    xs[i] = (op == 0) ? (xs[j] + xs[k]) : ((xs[j] < xs[k]) ? 1 : 0);
    // writeln(a, " ", b, "; ", xs);
  }
  assert(a * b == xs[2], format("%s * %s = %s", a, b, xs[2]));
}

void main() {
  enum A = 0, B = 1, ans = 2;
  enum zero = 3;
  enum one = 4;
  cmp(10, zero, A);
  cmp(11, zero, B);
  add(12, 10, 11);
  cmp(one, zero, 12);
  
  int[] makeTwo(int head, int ini) {
    auto two = iota(head, head + 2 * E).array;
    add(two[0], ini, zero);
    foreach (i; 1 .. 2 * E) {
      add(two[i], two[i - 1], two[i - 1]);
    }
    return two;
  }
  
  const two = makeTwo(100, one);
  
  enum sa = 5;
  enum sb = 6;
  add(sa, zero, zero);
  foreach_reverse (i; 0 .. E) {
    add(sb, zero, zero);
    foreach_reverse (j; 0 .. E) {
      // sa + 2^i <= A && sb + 2^j <= B
      add(20, sa, two[i]);
      add(21, sb, two[j]);
      add(22, A, one);
      add(23, B, one);
      cmp(24, 20, 22);
      cmp(25, 21, 23);
      add(26, 24, 25);
      cmp(26, one, 26);
      const twoFake = makeTwo(200, 26);
      add(ans, ans, twoFake[i + j]);
      add(sb, sb, twoFake[j]);
    }
    // sa + 2^i <= A
    {
      add(20, sa, two[i]);
      add(22, A, one);
      cmp(24, 20, 22);
      const twoFake = makeTwo(200, 24);
      add(sa, sa, twoFake[i]);
    }
  }
  
  writeln(program.length);
  foreach (line; program) {
    writefln("%s %s %s %s", "+<"[line[0]], line[2], line[3], line[1]);
  }
  
  debug {
    foreach (a; 0 .. 10 + 1) foreach (b; 0 .. 10 + 1) {
      test(a, b);
    }
    foreach (a; 10L^^9 - 10 .. 10L^^9 + 1) foreach (b; 10L^^9 - 10 .. 10L^^9 + 1) {
      test(a, b);
    }
  }
}
