import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.EOFException;
/**
 * Rahmen-Klasse für einen top-down Parser ("Recursive Descent")
 */
public class Aufgabe7Sol {
    private char[] line;
    private int currentPosition;
    /**
     * Constructor nimmt eine zu parsende Zeile entgegen 
     * und fügt einen Terminator '$' an.
     */
    public Aufgabe7Sol(String line) {
        this.line = (line+"$").toCharArray();
        this.currentPosition = 0;
    }

    /**
     * Starte den Parser die Zeile und gebe das Ergebnis aus.
     */
    public int run() {
        return parse_zeile(); /*parse eine Zeile */        
    }

    /**
     * Hilfsfunktion:
     *    Gibt das nächste anstehende Zeichen zurück
     */
    private char next() {
        return this.line[this.currentPosition];
    }

    /**
     * Hilfsfunktion:
     *    Verbraucht das aktuelle Zeichen und gibt es zurück.
     */
    private char advance() {
        char c = this.line[this.currentPosition];
        this.currentPosition++;
        return c;
    }

    /**
     * Hilfsfunktion:
     *    Tested, ob der Buchstabe in der Menge vorkommt
     */
    private boolean isInSet(char c, String s) {
        return s.indexOf(c)!=-1;
    }
    

    /**
     * Parse einem Integer und gebe den Wert zurück
     */
    private int parse_Z() {
        int result = 0;
        while (Character.isDigit(next())) {
            result = result*10 +  Character.digit(next(),10);
            advance();
        }
        return result;
    }




    /**
     * Parse die Zeile und gebe das Ergebnis zurück.
     */
    private int parse_zeile() {
        /* Teste ob der nächste Buchstabe ein terminales
         * Präfixe der Länge 1 von <zeile> -> <addition> ist.
         * Andernfalls wird eine Exception.
         */
        if (isInSet(next(),"(0123456789")) {
            return parse_addition();
        } else if (isInSet(next(),"$")) {
            return 0;//leere Zeile
        } else {
            throw new RuntimeException("parse_zeile: Kann keine Regel "
                                      +"für \""+next()+"\" anwenden");
        }
    }

    /**
     * Parse <addition>
     */
    private int parse_addition() {
        // Teste terminales  Präfix
        if (isInSet(next(),"(0123456789")) {
            return parse_multiplikation()+parse_addition2();
        } else {
            throw new RuntimeException("parse_addition: Kann keine Regel "
                                      +"für \""+next()+"\" anwenden");
        }
    }

    /**
     * Parse <addition'>
     */
    private int parse_addition2() {
        // Teste terminales  Präfix
        if (isInSet(next(),"+")) {
            advance();//Verbrauche +
            return parse_multiplikation()+parse_addition2();
        } else if (isInSet(next(),"-")) {
            advance();//Verbrauche -
            return -parse_multiplikation()+parse_addition2();
        } else if (isInSet(next(),"$)")) {//Ende der Zeile oder Rekursionsende
            return 0;
        } else {
            throw new RuntimeException("parse_addition2: Kann keine Regel "
                                      +"für \""+next()+"\" anwenden");
        }
    }


    /**
     * Parse <multiplikation>
     */
    private int parse_multiplikation() {
        // Teste terminales  Präfix
        if (isInSet(next(),"(0123456789")) {
            int erster_teil = parse_subausdruck();
            return parse_multiplikation2(erster_teil);
        } else {
            throw new RuntimeException("parse_multiplikation: Kann keine Regel "
                                      +"für \""+next()+"\" anwenden");
        }
    }

    /**
     * Parse <multiplikation'>
     */
    private int parse_multiplikation2(int vorderer_teil) {
        // Teste terminales  Präfix
        if (isInSet(next(),"*")) {
            advance();//Verbrauche *
            vorderer_teil = vorderer_teil*parse_subausdruck();
            return parse_multiplikation2(vorderer_teil);
        } else if (isInSet(next(),"/")) {
            advance();//Verbrauche /
            vorderer_teil = vorderer_teil/parse_subausdruck();
            return parse_multiplikation2(vorderer_teil);
        } else if (isInSet(next(),"+-$)")) {//Ende der Zeile oder Rekursionsende
            return vorderer_teil;
        } else {
            throw new RuntimeException("parse_multiplikation2: Kann keine Regel "
                                      +"für \""+next()+"\" anwenden");
        }
    }

    /**
     * Parse <subausdruck>
     */
    private int parse_subausdruck() {
        // Teste terminales  Präfix
        if (isInSet(next(),"(")) {
            advance();
            int innerer_teil = parse_addition();
            if (isInSet(next(),"(")) {
                advance();
                return innerer_teil;
            } else {
                throw new RuntimeException("parse_subausdruck: Mismatch für \""
                                          +next()
					  +"\" bei der schließenden Klammer");
            }
        } else if (isInSet(next(),"0123456789")) {
            return parse_Z();
        } else {
            throw new RuntimeException("parse_subausdruck: Kann keine Regel "
                                      +"für \""+next()+"\" anwenden");
        }
        
    }

    public static void main(String[] args) {
        try {
            System.out.print('>');
            BufferedReader input
		= new BufferedReader(new InputStreamReader(System.in));
            while (true) {
                String line = input.readLine(); 
                if (line==null) {
                    System.out.println();
                    System.exit(0);
                }
                Aufgabe7Sol parser = new Aufgabe7Sol(line);
                System.out.println(parser.run());
                System.out.print('>');
            }
        } catch (EOFException e) {
            System.out.println();
        } catch (IOException e) {
            System.out.println(e);
        }

    }
}