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;
vector<pair<unsigned long long, unsigned long long>> ans;
vector<int> op;
pair<long long, long long> ex_euclid(long long x, long long y) {
  if (x == 0) return make_pair(0, -1);
  pair<long long, long long> ret = ex_euclid(y % x, x);
  ret.second = -ret.first;
  ret.first = ((long long)1 + y * ret.second) / x;
  while (ret.first >= 0 && ret.second >= 0) {
    ret.first -= y;
    ret.second -= x;
  }
  while (ret.first < 0 || ret.second < 0) {
    ret.first += y;
    ret.second += x;
  }
  return ret;
}
void solve() {
  printf("%d\n", (int)ans.size());
  for (int i = 0; i < (int)ans.size(); i++) {
    if (op[i] == 1) {
      printf("%llu + %llu\n", ans[i].first, ans[i].second);
    } else
      printf("%llu ^ %llu\n", ans[i].first, ans[i].second);
  }
}
int main() {
  unsigned long long x;
  scanf("%llu", &x);
  if (x & 2) {
    ans.push_back(make_pair(x, x));
    ans.push_back(make_pair(x, x * 2));
    op.push_back(1);
    op.push_back(2);
    x = x ^ (x * 2);
  }
  int idx;
  for (idx = 30; idx >= 0; idx--)
    if (x & ((unsigned long long)1 << idx)) break;
  unsigned long long tmp = x;
  for (int i = 1; i <= idx; i++) {
    ans.push_back(make_pair(tmp, tmp));
    op.push_back(1);
    tmp <<= 1;
  }
  unsigned long long tmp1 = tmp + x, tmp2 = tmp ^ x;
  ans.push_back(make_pair(tmp, x));
  ans.push_back(make_pair(tmp, x));
  ans.push_back(make_pair(tmp1, tmp2));
  op.push_back(1);
  op.push_back(2);
  op.push_back(2);
  unsigned long long y = tmp1 ^ tmp2;
  pair<long long, long long> rrans = ex_euclid(x, y);
  pair<unsigned long long, unsigned long long> rans;
  rans.first = rrans.first;
  rans.second = rrans.second;
  vector<int> bita, bitb;
  for (int i = 63; i >= 0; i--) {
    if (rans.first & ((unsigned long long)1 << i)) bita.push_back(i);
    if (rans.second & ((unsigned long long)1 << i)) bitb.push_back(i);
  }
  vector<unsigned long long> tmpa, tmpb;
  tmpa.push_back(x);
  tmpb.push_back(y);
  unsigned long long curx = x, cury = y;
  for (int i = 1; i <= bita[0]; i++) {
    ans.push_back(make_pair(curx, curx));
    op.push_back(1);
    curx <<= 1;
    tmpa.push_back(curx);
  }
  for (int i = 1; i <= bitb[0]; i++) {
    ans.push_back(make_pair(cury, cury));
    op.push_back(1);
    cury <<= 1;
    tmpb.push_back(cury);
  }
  unsigned long long cura = tmpa.back(), curb = tmpb.back();
  for (int i = 1; i < (int)bita.size(); i++) {
    ans.push_back(make_pair(cura, tmpa[bita[i]]));
    op.push_back(1);
    cura += tmpa[bita[i]];
  }
  for (int i = 1; i < (int)bitb.size(); i++) {
    ans.push_back(make_pair(curb, tmpb[bitb[i]]));
    op.push_back(1);
    curb += tmpb[bitb[i]];
  }
  assert(cura - curb == 1);
  if (curb & 1) {
    ans.push_back(make_pair(curb, curb));
    ans.push_back(make_pair(curb, cura));
    op.push_back(1);
    op.push_back(1);
    curb = curb * 2;
    cura = curb * 2 + 1;
  }
  ans.push_back(make_pair(curb, cura));
  op.push_back(2);
  solve();
  return 0;
}