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

using namespace std;

struct Token
{
    int value;
    string strValue;
    enum Type
    {
        Number,
        Plus,
        Mult,
        LeftParen,
        RightParen,

        Semicolon,
        Assign,
        In,
        Out,
        Variable
    } type;

    Token(int val, Type t) : value(val), type(t) {}
    Token(const string & val) : strValue(val), type(Type::Variable) {}
   
};

bool strIsLow(const string & str) {
    for (auto &&c : str) {
        if (c > 'z' || c < 'a')
            return false;
    }
    return true;
}

vector<Token> Tokenize(istream& in)
{
    string s;
    vector<Token> tokens;
    while (in >> s)
    {
        if (s == "EOF") {
            break;
        }


#define tok(expr, res) else if (s == expr) { tokens.emplace_back(0, res); }
        tok("+", Token::Plus)
        tok("*", Token::Mult)
        tok("(", Token::LeftParen)
        tok(")", Token::RightParen)
        tok(";", Token::Semicolon)
        tok("=", Token::Assign)
        tok("<", Token::Out)
        tok(">", Token::In)
#undef tok
        else if (strIsLow(s)) {
            tokens.emplace_back(s);
        }
        else {
            stringstream ss(s);
            int i;
            ss >> i;
            tokens.emplace_back(i, Token::Number);
        }
    }
    return tokens;
}

using Scope = map<string, int>;

class Expression
{
public:
    virtual int eval(Scope & s) = 0;

};

class NumExpr : public Expression
{
private:
    int value;

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

    virtual int eval(Scope & s)
    {
        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(Scope & s) {
        return l->eval(s) * r->eval(s);
    }
};

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(Scope & s) {
        return l->eval(s) + r->eval(s);
    }
};

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

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

    }
    virtual int eval(Scope & s) {
        l->eval(s);
        return r->eval(s);
    }
};

class AssignExpr : public Expression
{
    string l;
    unique_ptr<Expression> r;

public:
    AssignExpr(const string &l, unique_ptr<Expression> &&r) : l(l), r(move(r)) {

    }
    virtual int eval(Scope& s) {
        return s[l]= r->eval(s);
    }
};

class ReadExpr : public Expression
{
    string l;

public:
    ReadExpr(const string &l) : l(l){

    }
    virtual int eval(Scope& s) {
        int x;
        cin >> x;
        return s[l] = x;
    }
};

class WriteExpr : public Expression
{
    unique_ptr<Expression> r;

public:
    WriteExpr(unique_ptr<Expression> &&r) : r(move(r)) {

    }
    virtual int eval(Scope& s) {
        cout << r->eval(s) << endl;
        return 0;
    }
};

class VarExpr : public Expression
{
private:
    string id;

public:
    VarExpr(string id) :
        id(id)
    {}

    virtual int eval(Scope & s)
    {
        return s[id];
    }
};


unique_ptr<Expression> parse_mult_exp(const vector<Token> & tokens, size_t& p);
unique_ptr<Expression> parse_add_exp(const vector<Token> & tokens, size_t& p);

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_variable(const vector<Token> & tokens, size_t& p) {
    if (p < tokens.size() && tokens[p].type == Token::Variable) {
        return make_unique<VarExpr>(tokens[p++].strValue);
    }

    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;

    ptr = parse_variable(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_add_exp(tokens, p);
        if (ptr && tokens[p].type == Token::RightParen)
        {
            ++p;
            return ptr;
        }
    }

    p = tmp;
    return unique_ptr<Expression>();
}

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>(move(l), move(r));
    }
    p = tmp;
    return l;
}

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::Mult)
    {
        ++p;
        unique_ptr<Expression> r = parse_mult_exp(tokens, p);
        if (r) return make_unique<MultExpr>(move(l), move(r));
    }
    p = tmp;

    return l;
}


unique_ptr<Expression> parse_stmt_exp(const vector<Token> & tokens, size_t& p)
{
    size_t bak = p;
    if (p < tokens.size() && tokens[p].type == Token::Out)
    {
        ++p;
        unique_ptr<Expression> r = parse_add_exp(tokens, p);
        if (r) return make_unique<WriteExpr>(move(r));
    }
    else if (p < tokens.size() && tokens[p].type == Token::In)
    {
        ++p;
        unique_ptr<Expression> r = parse_variable(tokens, p);
        if (r) return make_unique<ReadExpr>(move(r));
    }
    else {
        unique_ptr<Expression> l = parse_variable(tokens, p);
        if (l) {
            if (p < tokens.size() && tokens[p].type == Token::Assign) {
                ++p;
                unique_ptr<Expression> r = parse_add_exp(tokens, p);
                if (r) return make_unique<AssignExpr>(move(l), move(r));
            }
        }

    }
    p = bak;
    return unique_ptr<Expression>();
}


unique_ptr<Expression> parse_prog_exp(const vector<Token> & tokens, size_t& p)
{
    unique_ptr<Expression> l = parse_stmt_exp(tokens, p);
    size_t tmp = p;
    if (!l) return l;
    if (p < tokens.size() && tokens[p].type == Token::Semicolon)
    {
        ++p;
        unique_ptr<Expression> r = parse_prog_exp(tokens, p);
        if (r) return make_unique<ProgExpr>(move(l), move(r));
    }
    p = tmp;
    return l;
}

int main()
{

    auto t = Tokenize(cin);
    size_t nula = 0;

    auto x = parse_add_exp(t, nula);
    Scope s;


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

}