Problem: In this problem you will write a simple generator of Brainfuck (<https://en.wikipedia.org/wiki/Brainfuck>) calculators.

You are given an arithmetic expression consisting of integers from 0 to 255 and addition/subtraction signs between them. Output a Brainfuck program which, when executed, will print the result of evaluating this expression.

We use a fairly standard Brainfuck interpreter for checking the programs:

  * 30000 memory cells.
  * memory cells store integers from 0 to 255 with unsigned 8-bit wraparound.
  * console input (, command) is not supported, but it's not needed for this problem.

Input

The only line of input data contains the arithmetic expression. The expression will contain between 2 and 10 operands, separated with arithmetic signs plus and/or minus. Each operand will be an integer between 0 and 255, inclusive. The calculations result is guaranteed to be an integer between 0 and 255, inclusive (results of intermediary calculations might be outside of these boundaries).

Output

Output a Brainfuck program which, when executed, will print the result of evaluating this expression. The program must be at most 5000000 characters long (including the non-command characters), and its execution must be complete in at most 50000000 steps.

Examples

Input

2+3


Output

++&gt;
+++&gt;
&lt;[&lt;+&gt;-]&lt;
++++++++++++++++++++++++++++++++++++++++++++++++.


Input

9-7


Output

+++++++++&gt;
+++++++&gt;
&lt;[&lt;-&gt;-]&lt;
++++++++++++++++++++++++++++++++++++++++++++++++.

Note

You can download the source code of the Brainfuck interpreter by the link [http://assets.codeforces.com/rounds/784/bf.cpp](//assets.codeforces.com/rounds/784/bf.cpp). We use this code to interpret outputs.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
template <class T>
void Read(T &x) {
  char c;
  bool f = 0;
  while (c = getchar(), c != EOF)
    if (c == '-')
      f = 1;
    else if (c >= '0' && c <= '9') {
      x = c - '0';
      while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
      ungetc(c, stdin);
      if (f) x = -x;
      return;
    }
}
namespace arr {
inline int lowbit(int x) { return x & (-x); }
template <class T>
inline void arrUpdate(T *c, int x, T d, int N) {
  while (x <= N) {
    c[x] += d;
    x += lowbit(x);
  }
}
template <class T>
inline T arrGetsum(T *c, int x) {
  T ret = 0;
  while (x) {
    ret += c[x];
    x -= lowbit(x);
  }
  return ret;
}
}  // namespace arr
namespace Polynomial {
namespace FFT {
struct cplx {
  double a, b;
  cplx() {}
  cplx(double a, double b = 0) : a(a), b(b) {}
  inline cplx operator+(const cplx &x) const { return cplx(a + x.a, b + x.b); }
  inline cplx operator-(const cplx &x) const { return cplx(a - x.a, b - x.b); }
  inline cplx operator*(const cplx &x) const {
    return cplx(a * x.a - b * x.b, a * x.b + b * x.a);
  }
  inline cplx &operator*=(const cplx &x) { return *this = *this * x; }
  inline double sqr(double x) const { return x * x; }
  inline cplx operator/(const cplx &x) const {
    double t = sqr(x.a) + sqr(x.b);
    return cplx((a * x.a + b * x.b) / t, (b * x.a - a * x.b) / t);
  }
  inline cplx operator/=(const cplx &x) { return *this = *this / x; }
};
void FFT(cplx *a, int n, int type) {
  for (int i = 1, j = 0; i < n; i++) {
    for (int t = n; j ^= (t >>= 1), (~j) & t;)
      ;
    if (i < j) swap(a[i], a[j]);
  }
  cplx x, y;
  for (int i = 1; i < n; i <<= 1) {
    cplx w1(cos(PI / i), sin(type * PI / i));
    for (int j = 0; j < n; j += i << 1) {
      cplx w(1, 0);
      for (int k = 0; k < i; k++) {
        x = a[j + k], y = w * a[j + k + i];
        a[j + k] = x + y, a[j + k + i] = x - y;
        w *= w1;
      }
    }
  }
  if (type == -1) {
    for (int i = 0; i < n; i++) a[i].a /= n, a[i].b /= n;
  }
}
void Multi(cplx *a, cplx *b, int n, int m) {
  m += n;
  for (n = 1; n <= m; n <<= 1)
    ;
  FFT(a, n, 1), FFT(b, n, 1);
  for (int i = 0; i < n; i++) a[i] *= b[i];
  FFT(a, n, -1);
}
}  // namespace FFT
namespace NTT {
inline int mypow(int x, int k) {
  int ret = 1;
  while (k) {
    if (k & 1) ret = 1LL * ret * x % (119 * (1 << 23) + 1);
    x = 1LL * x * x % (119 * (1 << 23) + 1);
    k >>= 1;
  }
  return ret;
}
void NTT(int *a, int n, int type) {
  for (int i = 1, j = 0; i < n; i++) {
    for (int t = n; j ^= (t >>= 1), (~j) & t;)
      ;
    if (i < j) swap(a[i], a[j]);
  }
  int x, y;
  for (int i = 1; i < n; i <<= 1) {
    int w1 = mypow(3, ((119 * (1 << 23) + 1) - 1) / (i << 1));
    for (int j = 0; j < n; j += i << 1) {
      int w = 1;
      for (int k = 0; k < i; k++) {
        x = a[j + k], y = 1LL * w * a[j + k + i] % (119 * (1 << 23) + 1);
        a[j + k] = (x + y) % (119 * (1 << 23) + 1),
              a[j + k + i] =
                  (x - y + (119 * (1 << 23) + 1)) % (119 * (1 << 23) + 1);
        w = 1LL * w * w1 % (119 * (1 << 23) + 1);
      }
    }
  }
  if (type == -1) {
    reverse(a + 1, a + n);
    long long inv = mypow(n, (119 * (1 << 23) + 1) - 2);
    for (int i = 0; i < n; i++) a[i] = 1LL * a[i] * inv % (119 * (1 << 23) + 1);
  }
}
void Multi(int *a, int *b, int n, int m) {
  m += n;
  for (n = 1; n <= m; n <<= 1)
    ;
  NTT(a, n, 1), NTT(b, n, 1);
  for (int i = 0; i < n; i++) a[i] = 1LL * a[i] * b[i] % (119 * (1 << 23) + 1);
  NTT(a, n, -1);
}
}  // namespace NTT
namespace FWT {
void Xor(int *f, int n) {
  int S = 1 << n;
  for (int i = 1; i < S; i <<= 1)
    for (int j = 1; j < S; j++)
      if (j & i) f[j] += f[j ^ i];
}
void iXor(int *f, int n) {
  int S = 1 << n;
  for (int i = 1; i < S; i <<= 1)
    for (int j = 1; j < S; j++)
      if (j & i) f[j] -= f[j ^ i];
}
}  // namespace FWT
}  // namespace Polynomial
int a[200], b[200], n, cnta, cntb, x, ans;
int main() {
  int x;
  while (cin >> x) ans += x;
  if (!ans) {
    printf("++++++++++++++++++++++++++++++++++++++++++++++++.\n");
  } else {
    for (; ans;) a[++cnta] = ans % 10, ans /= 10;
    for (int i = cnta; i >= 1; i--) {
      a[i] += 48;
      while (a[i]--) printf("+");
      puts(".");
      puts(">");
    }
  }
  return 0;
}