#include <iostream>
#include <vector>
#include <string>
#include <sstream>

using namespace std;

struct Token
{
    int value;
   
    enum Type
    {
        Number,
        Plus,
        Mult,
        LeftParen,
        RightParen
    } type;

    Token(int val, Type t) : value(val), type(t) {}
};

vector<Token> Tokenize(istream& in)
{
    string s;
    vector<Token> tokens;
    while (in >> s)
    {
        if (s == "+")
        {
            tokens.emplace_back(0, Token::Plus);
        }
        else if (s == "*")
        {
            tokens.emplace_back(0, Token::Mult);
        }
        else if (s == "(")
        {
            tokens.emplace_back(0, Token::LeftParen);
        }
        else if (s == ")")
        {
            tokens.emplace_back(0, Token::RightParen);
        }
        else {
            stringstream ss(s);
            int i;
            ss >> i;
            tokens.emplace_back(i, Token::Number);
        }
    }
    return tokens;
}

class Expression
{
public:
    virtual int eval() = 0;
};

class NumExpr : public Expression
{
private:
    int value;

public:
    NumExpr(int value) :
        value(value)
    {}

    virtual int eval()
    {
        return value;
    }
};

class MultExpr : public Expression
{
    unique_ptr<Expression> l, r;

public:
    MultExpr(unique_ptr<Expression> &&l, unique_ptr<Expression> &&r) : l(move(l)), r(move(r)) {

    }

    virtual int eval() {
        return l->eval() * r->eval();
    }
};

class AddExpr : public Expression
{
    unique_ptr<Expression> l, r;

public:
    AddExpr(unique_ptr<Expression> &&l, unique_ptr<Expression> &&r) : l(move(l)), r(move(r)) {

    }
    virtual int eval() {
        return l->eval() + r->eval();
    }
};

unique_ptr<Expression> parse_number(const vector<Token> & tokens, size_t& p) {
    if (p < tokens.size() && tokens[p].type == Token::Number) {
        return make_unique<NumExpr>(tokens[p++].value);
    }

    return unique_ptr<Expression>();
}

unique_ptr<Expression> parse_basic_exp(const vector<Token> & tokens, size_t& p) {
    unique_ptr<Expression> ptr = parse_number(tokens, p);
    if (ptr)
        return ptr;

    size_t tmp = p;

    if (p < tokens.size() && tokens[p].type == Token::LeftParen)
    {
        ++p;
        unique_ptr<Expression> ptr = parse_basic_exp(tokens, p);
        if (ptr && tokens[p].type == Token::RightParen)
        {
            ++p;
            return ptr;
        }
    }

    p = tmp;
    return parse_add_exp(tokens, p);
}

unique_ptr<Expression> parse_add_exp(const vector<Token> & tokens, size_t& p)
{
    unique_ptr<Expression> l = parse_mult_exp(tokens, p);
    size_t tmp = p;
    if (!l) return l;
    if (p < tokens.size() && tokens[p].type == Token::Plus)
    {
        ++p;
        unique_ptr<Expression> r = parse_add_exp(tokens, p);
        if (r) return make_unique<AddExpr>(l, r);
    }
    p = tmp;
    return unique_ptr<Expression>();
}

unique_ptr<Expression> parse_mult_exp(const vector<Token> & tokens, size_t& p)
{
    unique_ptr<Expression> l = parse_basic_exp(tokens, p);
    size_t tmp = p;
    if (!l) return l;
    if (p < tokens.size() && tokens[p].type == Token::Plus)
    {
        ++p;
        unique_ptr<Expression> r = parse_mult_exp(tokens, p);
        if (r) return make_unique<MultExpr>(l, r);
    }
    p = tmp;
    return unique_ptr<Expression>();
}

int main()
{
   
    auto t = Tokenize(cin);
    size_t nula = 0;

    auto x = parse_basic_exp(t, nula);



    std::cout << x->eval() <<'\n';
    std::cout << nula << '\n';

}