#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <algorithm>
#include <bitset>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <cassert>
#include <functional>

typedef long long ll;
using namespace std;

#ifndef LOCAL
#define debug(...) ;
#else
#define debug(...) cerr << __LINE__ << " : " << #__VA_ARGS__ << " = " << _tostr(__VA_ARGS__) << endl;

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);

template<typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
  out << "{" << p.first << ", " << p.second << "}";
  return out;
}

template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
  out << '{';
  for (const T &item : v) out << item << ", ";
  out << "\b\b}";
  return out;
}

void _tostr_rec(ostringstream &oss) {
  oss << "\b\b \b";
}

template<typename Head, typename... Tail>
void _tostr_rec(ostringstream &oss, Head &&head, Tail &&... tail) {
  oss << head << ", ";
  _tostr_rec(oss, forward<Tail>(tail)...);
}

template<typename... T>
string _tostr(T &&... args) {
  ostringstream oss;
  int size = sizeof...(args);
  if (size > 1) oss << "{";
  _tostr_rec(oss, forward<T>(args)...);
  if (size > 1) oss << "}";
  return oss.str();
}
#endif

#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 200010


vector<string> vec;

int ARR[SIZE];
int outputCounter = 0;

void add(int i, int j, int k) {
  ARR[k] = ARR[i] + ARR[j];
  printf("+ %d %d %d\n", i, j, k);
  outputCounter++;
}

void comp(int i, int j, int k) {
  ARR[k] = ARR[i] < ARR[j];
  printf("< %d %d %d\n", i, j, k);
  outputCounter++;
}

int main() {
  int A, B;

  puts("33548");

  //cin >> A >> B;
  A = 200;
  B = 4412;

  ARR[0] = A;
  ARR[1] = B;

  const int AA = 0, BB = 1;
  const int ONE = 101;
  const int ZERO = 100;
  int POW2[70], POW2A[40], POW2B[40];
  int ANS = 2;

  comp(ZERO, AA, 20);
  comp(ZERO, BB, 21);
  add(20, 21, 22);
  comp(ZERO, 22, ONE);

  add(AA, ONE, AA);
  add(BB, ONE, BB);

  for (int i = 0; i < 60; i++) {
    POW2[i] = 1000 + i;
    add(ONE, POW2[i], POW2[i]);
    for (int j = 0; j < i; j++) {
      add(POW2[i], POW2[i], POW2[i]);
    }
  }

  int SUMA = 20, SUMB = 21, CA = 22, CB = 23, TA = 24, TB = 25;
  add(ZERO, ZERO, SUMA);
  add(ZERO, ZERO, SUMB);

  for (int i = 29; i >= 0; i--) {
    POW2A[i] = 2000 + i;
    POW2B[i] = 3000 + i;

    add(SUMA, POW2[i], TA);
    comp(TA, AA, CA);
    add(SUMB, POW2[i], TB);
    comp(TB, BB, CB);

    add(CA, ZERO, POW2A[i]);
    add(CB, ZERO, POW2B[i]);

    for (int j = 0; j < i; j++) {
      add(CA, CA, CA);
      add(CB, CB, CB);
    }
    add(SUMA, CA, SUMA);
    add(SUMB, CB, SUMB);
  }

  for (int i = 0; i < 30; i++) {
    debug(ARR[POW2A[i]], ARR[POW2B[i]]);
  }

  for (int i = 0; i < 30; i++) {
    for (int j = 0; j < 30; j++) {
      int T1 = 20, T2 = 21;
      comp(ZERO, POW2A[i], T1);
      comp(ZERO, POW2B[j], T2);
      add(T1, T2, T2);
      comp(ONE, T2, T1);

      for (int k = 0; k < i + j; k++) {
        add(T1, T1, T1);
      }
      add(T1, ANS, ANS);
    }
  }

  debug(ARR[2]);
  debug(outputCounter);

  assert(A * B == ARR[2]);

  return 0;
}

Measured memory_bytes: 3736