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 JAVA):

Solution:

import java.util.*;
import java.io.*;


public class ProblemC {

    public static int mod = 1000000007;
    public static InputReader in;
    public static PrintWriter out;
    
    public static void main(String[] args) throws FileNotFoundException {

        in = new InputReader(System.in);
        out = new PrintWriter(System.out);
        
        String s=in.readString();
        int n=s.length();
        int ans=0;
        char c='+';
        for(int i=0;i<n;i++){
            String tmp="";
            int j=i;
            while(i<n && s.charAt(i)!='+' && s.charAt(i)!='-'){
                tmp+=s.charAt(i);
                i++;
            }
            int x=Integer.parseInt(tmp);
            if(c=='+') ans+=x;
            else ans-=x;
            if(i<n)c=s.charAt(i);
        }
        s=ans+"";
        for(int i=0;i<s.length();i++){
            for(int j=0;j<s.charAt(i);j++) out.print('+');
            out.println('.');
            if(i!=s.length()-1){
                for(int j=0;j<s.charAt(i);j++) out.print('-');
                out.println();
            }
        }
        
        out.close();
    }
    
 
    public static void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}
    static class Pair{
            int x;
            int y;
            int i;
            Pair(int x,int y){
                    this.x=x;
                    this.y=y;
            }
            Pair(int x,int y,int i){
                    this.x=x;
                    this.y=y;
                    this.i=i;
            }

        @Override
        public String toString() {
            return x+" "+y;
        }

            
    }

    public static class CompareTable implements Comparator{
        public int compare(Object o1,Object o2){
            Pair p1 = (Pair) o1;
            Pair p2 = (Pair) o2;

            if(p1.x!=p2.x) return Integer.compare(p1.x, p2.x);
            else return Integer.compare(p1.y, p2.y);
        }
    }
    

    public static long add(long x, long y) {
    return (x + y)%mod;
    }

    public static long mul(long x, long y) {
    return (x*y)%mod;
    }
    public static boolean isPal(String s){
        for(int i=0, j=s.length()-1;i<=j;i++,j--){
                if(s.charAt(i)!=s.charAt(j)) return false;
        }
        return true;
    }
    public static String rev(String s){
            StringBuilder sb=new StringBuilder(s);
            sb.reverse();
            return sb.toString();
    }

    public static long gcd(long x,long y){
    if(x%y==0)
            return y;
    else
            return gcd(y,x%y);
    }

    public static int gcd(int x,int y){
    if(x%y==0)
            return y;
    else 
            return gcd(y,x%y);
    }

    public static long gcdExtended(long a,long b,long[] x){

        if(a==0){
            x[0]=0;
            x[1]=1;
            return b;
        }
        long[] y=new long[2];
        long gcd=gcdExtended(b%a, a, y);

        x[0]=y[1]-(b/a)*y[0];
        x[1]=y[0];

        return gcd;
    }

    public static int abs(int a,int b){
    return (int)Math.abs(a-b);
    }

    public static long abs(long a,long b){
    return (long)Math.abs(a-b);
    }

    public static int max(int a,int b){
    if(a>b)
            return a;
    else
            return b;
    }

    public static int min(int a,int b){
    if(a>b)
            return b;
    else 
            return a;
    }

    public static long max(long a,long b){
    if(a>b)
            return a;
    else
            return b;
    }

    public static long min(long a,long b){
    if(a>b)
            return b;
    else 
            return a;
    }

    public static long pow(long n,long p,long m){
     long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;
        if(result>=m)
        result%=m;
        p >>=1;
        n*=n;
        if(n>=m)
        n%=m;
    }
    return result;
    }

    public static long pow(long n,long p){
    long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;	    
        p >>=1;
        n*=n;	    
    }
    return result;
    }

    static class InputReader {

            private final InputStream stream;
            private final byte[] buf = new byte[8192];
            private int curChar, snumChars;
            private SpaceCharFilter filter;

            public InputReader(InputStream stream) {
                    this.stream = stream;
            }

            public int snext() {
                    if (snumChars == -1)
                            throw new InputMismatchException();
                    if (curChar >= snumChars) {
                            curChar = 0;
                            try {
                                    snumChars = stream.read(buf);
                            } catch (IOException e) {
                                    throw new InputMismatchException();
                            }
                            if (snumChars <= 0)
                                    return -1;
                    }
                    return buf[curChar++];
            }

            public int nextInt() {
                    int c = snext();
                    while (isSpaceChar(c)) {
                            c = snext();
                    }
                    int sgn = 1;
                    if (c == '-') {
                            sgn = -1;
                            c = snext();
                    }
                    int res = 0;
                    do {
                            if (c < '0' || c > '9')
                                    throw new InputMismatchException();
                            res *= 10;
                            res += c - '0';
                            c = snext();
                    } while (!isSpaceChar(c));
                    return res * sgn;
            }

            public long nextLong() {
                    int c = snext();
                    while (isSpaceChar(c)) {
                            c = snext();
                    }
                    int sgn = 1;
                    if (c == '-') {
                            sgn = -1;
                            c = snext();
                    }
                    long res = 0;
                    do {
                            if (c < '0' || c > '9')
                                    throw new InputMismatchException();
                            res *= 10;
                            res += c - '0';
                            c = snext();
                    } while (!isSpaceChar(c));
                    return res * sgn;
            }

            public int[] nextIntArray(int n) {
                    int a[] = new int[n];
                    for (int i = 0; i < n; i++) {
                            a[i] = nextInt();
                    }
                    return a;
            }

            public long[] nextLongArray(int n) {
                    long a[] = new long[n];
                    for (int i = 0; i < n; i++) {
                            a[i] = nextInt();
                    }
                    return a;
            }

            public String readString() {
                    int c = snext();
                    while (isSpaceChar(c)) {
                            c = snext();
                    }
                    StringBuilder res = new StringBuilder();
                    do {
                            res.appendCodePoint(c);
                            c = snext();
                    } while (!isSpaceChar(c));
                    return res.toString();
            }

            public String nextLine() {
                    int c = snext();
                    while (isSpaceChar(c))
                            c = snext();
                    StringBuilder res = new StringBuilder();
                    do {
                            res.appendCodePoint(c);
                            c = snext();
                    } while (!isEndOfLine(c));
                    return res.toString();
            }

            public boolean isSpaceChar(int c) {
                    if (filter != null)
                            return filter.isSpaceChar(c);
                    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }

            private boolean isEndOfLine(int c) {
                    return c == '\n' || c == '\r' || c == -1;
            }

            public interface SpaceCharFilter {
                    public boolean isSpaceChar(int ch);
            }
    }
}