import java.util.HashMap;

class Parser {
    static final int EOI = 0;
    static final int NUM = 1;
    static final int ID = 2;
    static final int PLUS = 3;
    static final int MINUS = 4;
    static final int ASTERISK = 5;
    static final int LP = 6;
    static final int RP = 7;

    static int yylval_num;
    static String yylval_str;

    static int yylex() throws java.io.IOException {
	char c = (char)System.in.read();
	if ('0' <= c && c <= '9') {
	    yylval_num = c - '0';
	    return NUM;
	}
	if ('a' <= c && c <= 'z') {
	    yylval_str = Character.toString(c);
	    return ID;
	}
	switch(c) {
	case '+': 
	    return PLUS;
	case '-':
	    return MINUS;
	case '*':
	    return ASTERISK;
	case '(':
	    return LP;
	case ')':
	    return RP;
	}
	    
	return EOI;
    }

    /*  E : T EP      { NUM, ID, LP }
     *  EP : + T EP   { PLUS }
     *     : - T EP   { MINUS }
     *     | eps      { EOI, RP }
     *  T : F TP      { NUM, ID, LP }
     *  TP : * F TP   { ASTERISK }
     *     | eps      { PLUS, MINUS, EOI, RP}
     *  F : NUM       { NUM }
     *    | ID        { ID }
     *    | ( E )     { LP }
     */

    static Expression E() throws java.io.IOException {
	System.out.println("E -> T EP");
	Expression t_attr = T();
	Expression ep_attr = EP(t_attr);
	return ep_attr;
    }

    static Expression EP(Expression prev)
	throws java.io.IOException {
	if (token == PLUS || token == MINUS) {
	    System.out.println("EP -> +- T EP");

	    char op = ' ';
	    if (token == PLUS)
		op = '+';
	    else if (token == MINUS)
		op = '-';

	    token = yylex();
	    Expression t_attr = T();
	    Expression e = Op(op, prev, t_attr);
	    Expression ep_attr = EP(e);
	    return ep_attr;
	} else if (token == EOI || token == RP) {
	    System.out.println("EP -> eps");
	    return prev;
	} else {
	    System.err.println("Greska");
	}
	return null;
    }

    static Expression T() throws java.io.IOException {
	System.out.println("T -> F TP");
	Expression f_attr = F();
	Expression tp_attr = TP(f_attr);
	return tp_attr;
    }

    static Expression TP(Expression prev) throws java.io.IOException {
	if (token == ASTERISK) {
	    System.out.println("TP -> * F TP");
	    token = yylex();
	    Expression f_attr = F();
	    Expression e = Op('*', prev, f_attr);
	    Expression tp_attr = TP(e);
	    return tp_attr;
	} else if (token == EOI || token == PLUS || token == MINUS || token == RP) {
	    System.out.println("TP -> eps");
	    return prev;
	} else {
	    System.err.println("Greska");
	}
	return null;
    }

    static Expression F() throws java.io.IOException {
	if (token == NUM) {
	    System.out.println("F -> NUM");
	    token = yylex();
	    Expression attr = new Constant(yylval_num);
	    return attr;
	} else if (token == ID) {
	    System.out.println("F -> ID");
	    token = yylex();
	    Expression attr = new Variable(yylval_str);
	    return attr;
	} else if (token == LP) {
	    System.out.println("F -> ( E )");
	    token = yylex();
	    Expression attr = E();
	    if (token != RP)
		System.err.println("Greska");
	    else
		token = yylex();
	    return attr;
	} else
	    System.err.println("Greska");
	return null;
    }

    public static void main(String[] args)  throws java.io.IOException  {
	token = yylex();
	Expression e = E();
	System.out.println(e.interpret(new HashMap<String, Integer>()));
    }    
}