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;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  os << "{";
  for (int i = 0; i < (int)v.size(); i++) {
    if (i) os << ", ";
    os << v[i];
  }
  os << "}";
  return os;
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
  cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
  const char* comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
vector<string> ops;
struct basis {
  vector<long long> V;
  int size;
  basis() { size = 0; }
  bool insert(long long x, bool add = true) {
    if (x == 0) return false;
    long long curr = add ? x : 0;
    vector<string> to_add;
    for (long long a : V)
      if (a & -a & x) {
        x ^= a;
        if (curr != 0) {
          to_add.push_back(to_string(curr) + " ^ " + to_string(a));
        }
        curr ^= a;
      }
    bool ret = x == 0;
    if (!add) {
      if (ret) {
        copy(((to_add).begin()), ((to_add).end()), back_inserter(ops));
      }
      return ret;
    }
    if (ret) return 0;
    copy(((to_add).begin()), ((to_add).end()), back_inserter(ops));
    for (long long& a : V) {
      if (x & -x & a) {
        ops.push_back(to_string(a) + " ^ " + to_string(x));
        a ^= x;
      }
    }
    V.push_back(x);
    size++;
    return 1;
  }
};
void go(long long x) {
  basis B;
  int X = x;
  x *= 2;
  for (; x < 1e18; x *= 2) {
    ops.push_back(to_string(x / 2) + " + " + to_string(x / 2));
    ops.push_back(to_string(x) + " + " + to_string(X));
    if (x != 2 * X) {
      ops.push_back(to_string(x / 2) + " + " + to_string(x / 2 - X));
    }
    B.insert(x - X);
    B.insert(x + X);
    if (B.insert(1, false)) {
      return;
    }
  }
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int x;
  cin >> x;
  go(x);
  cout << ops.size() << "\n";
  for (auto it : ops) cout << it << "\n";
  cout << "\n";
}