Problem: You have a blackboard and initially only an odd number x is written on it. Your goal is to write the number 1 on the blackboard.

You may write new numbers on the blackboard with the following two operations. 

  * You may take two numbers (not necessarily distinct) already on the blackboard and write their sum on the blackboard. The two numbers you have chosen remain on the blackboard. 
  * You may take two numbers (not necessarily distinct) already on the blackboard and write their [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) on the blackboard. The two numbers you have chosen remain on the blackboard. 

Perform a sequence of operations such that at the end the number 1 is on the blackboard.

Input

The single line of the input contains the odd integer x (3 ≤ x ≤ 999,999).

Output

Print on the first line the number q of operations you perform. Then q lines should follow, each describing one operation. 

  * The "sum" operation is described by the line "a + b", where a, b must be integers already present on the blackboard. 
  * The "xor" operation is described by the line "a ^ b", where a, b must be integers already present on the blackboard. 

The operation symbol (+ or ^) must be separated from a, b by a whitespace.

You can perform at most 100,000 operations (that is, q≤ 100,000) and all numbers written on the blackboard must be in the range [0, 5⋅10^{18}]. It can be proven that under such restrictions the required sequence of operations exists. You can output any suitable sequence of operations.

Examples

Input


3


Output


5
3 + 3
3 ^ 6
3 + 5
3 + 6
8 ^ 9


Input


123


Output


10
123 + 123
123 ^ 246
141 + 123
246 + 123
264 ^ 369
121 + 246
367 ^ 369
30 + 30
60 + 60
120 ^ 121

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int randomInt(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
const int K = 60;
bool setBit(long long x, int i) { return x & (1LL << i); }
struct info {
  long long op1, op2;
  char cmd;
  info(long long op1, char cmd, long long op2) : op1(op1), cmd(cmd), op2(op2) {}
};
vector<info> vi;
void _jog(long long x, long long y) { vi.emplace_back(x, '+', y); }
void _jor(long long x, long long y) { vi.emplace_back(x, '^', y); }
struct Basis {
  long long b[K];
  Basis() { memset(b, 0, sizeof b); }
  bool canForm(long long x) {
    for (int i = K - 1; i >= 0; i--) {
      if (setBit(x, i)) {
        if (setBit(b[i], i)) {
          x ^= b[i];
        }
      }
    }
    return x == 0;
  }
  void addNumber(long long x) {
    for (int i = K - 1; i >= 0; i--) {
      if (setBit(x, i)) {
        if (setBit(b[i], i)) {
          _jor(x, b[i]);
          x ^= b[i];
        } else {
          b[i] = x;
          return;
        }
      }
    }
    assert(false);
  }
  vector<long long> _getRandom() {
    vector<long long> w;
    for (int i = K - 1; i >= 0; i--) {
      if (b[i]) {
        if (randomInt(0, 1)) {
          w.push_back(b[i]);
        }
      }
    }
    return w;
  }
  vector<long long> getRandom() {
    vector<long long> w;
    while (true) {
      w = _getRandom();
      if (!w.empty()) break;
    }
    return w;
  }
};
int main() {
  long long x;
  cin >> x;
  Basis basis;
  basis.addNumber(x);
  while (basis.b[0] == 0) {
    vector<long long> vp = basis.getRandom();
    vector<long long> vq = basis.getRandom();
    long long p = 0;
    for (long long z : vp) p ^= z;
    long long q = 0;
    for (long long z : vq) q ^= z;
    if (p + q >= (1LL << K)) continue;
    if (basis.canForm(p + q)) continue;
    p = vp[0];
    for (int i = 1; i < vp.size(); i++) {
      _jor(p, vp[i]);
      p ^= vp[i];
    }
    q = vq[0];
    for (int i = 1; i < vq.size(); i++) {
      _jor(q, vq[i]);
      q ^= vq[i];
    }
    _jog(p, q);
    basis.addNumber(p + q);
  }
  cout << vi.size() << "\n";
  for (info i : vi) {
    cout << i.op1 << " " << i.cmd << " " << i.op2 << "\n";
  }
  return 0;
}