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 LIM_AB = 10;
enum LEN = 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 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);
  
  enum iterA = 5;
  enum iterB = 6;
  add(iterA, zero, zero);
  foreach (i; 0 .. LIM_AB) {
    add(iterB, zero, zero);
    foreach (j; 0 .. LIM_AB) {
      // ans += [i < A] [j < B]
      cmp(20, iterA, A);
      cmp(21, iterB, B);
      add(22, 20, 21);
      cmp(22, one, 22);
      add(ans, ans, 22);
      add(iterB, iterB, one);
    }
    add(iterA, iterA, one);
  }
  
  foreach (line; program) {
    writefln("%s %s %s %s", "+<"[line[0]], line[2], line[3], line[1]);
  }
  
  debug {
    foreach (a; 0 .. LIM_AB + 1) foreach (b; 0 .. LIM_AB + 1) {
      auto xs = new int[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]));
    }
  }
}
