#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <map>
using namespace std;

using scope = map<string, int>;


struct Token
{
    enum tt { num, plus, left_p, right_p, mult, assign, input, output, semicolon, var };

    tt type;
    int n;
    string name;

    Token(tt t, int n = 0) : type(t), n(n) {}

    Token(const string &name) : type(var), name(name) {}
};

class Expr {
public:
    virtual int eval(scope&) = 0;
};

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

public:

    ProgExpr(unique_ptr<Expr> &&l, unique_ptr<Expr> &&r) : l(move(l)), r(move(r))
    {}

    int eval(scope &s)
    {
        l->eval(s);
        r->eval(s);

        return 0;
    }
};

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

    AssignExpr(const string &l, unique_ptr<Expr> &&r) : l(l), r(move(r))
    {}

    int eval(scope &s)
    {
        s[l] = r->eval(s);

        return 0;
    }
};

class OutputExpr : public Expr {
private:
    unique_ptr<Expr> r;
public:

    OutputExpr(unique_ptr<Expr> &&r) : r(move(r))
    {}

    int eval(scope &s)
    {
        cout << r->eval(s) << std::endl;
        return 0;
    }
};

class InputExpr : public Expr{
private:
    string l;
public:

    InputExpr(const string &l) : l(l)
    {}

    int eval(scope &s)
    {
        cin >> s[l];
        return 0;
    }
};

class NumExpr : public Expr {
private:
    int val;
public:
    int eval(scope&) {
        return val;
    }
    NumExpr(int val) : val(val) {}
};

class VarExpr : public Expr {
    private:
        string name;
    public:
        int eval(scope& s) {
            return s[name];
        }
        VarExpr(const string& name) : name(name) {}
};

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

public:

    AddExpr(unique_ptr<Expr> &&l, unique_ptr<Expr> &&r) : l(move(l)), r(move(r))
    {}

    int eval(scope &s)
    {
        return l->eval(s) + r->eval(s);
    }
};

class MulExpr : public Expr {
private:
    unique_ptr<Expr>l, r;

public:

    MulExpr(unique_ptr<Expr> &&l, unique_ptr<Expr> &&r) : l(move(l)), r(move(r))
    {}

    int eval(scope &s)
    {
        return l->eval(s) * r->eval(s);
    }
};

bool isVar(const string &v)
{
    for (char c : v)
    {
        if ((c < 'a') || (c > 'z'))
        {
            return false;
        }
    }
    return true;
}

vector<Token> tokenize(istream &is)
{
    string str;

    vector<Token> vec;

#define token(s, t) \
    else if (str == s) {\
    vec.emplace_back(Token::t);\
        }

    while (is >> str) {
        if (str == "EOF")
        {
            break;
        }

        token("*", mult)
        token("+", plus)
        token("(", left_p)
        token(")", right_p)
        token(";", semicolon)
        token("=", assign)
        token("<", output)
        token(">", input)
#undef token
        else if(isVar(str)) {
            vec.emplace_back(str);
        }
        else {
            vec.emplace_back(Token::num, stoi(str));
        }
    }

    return vec;
}


unique_ptr<Expr> parseAddExpr(const vector<Token> &tokens, size_t &pos);
unique_ptr<Expr> parseMultExpr(const vector<Token> &tokens, size_t &pos);


unique_ptr<Expr> parseExp(const vector<Token> &tokens, size_t &pos) {
    return parseAddExpr(tokens, pos);
}

unique_ptr<Expr> parseNum(const vector<Token> &tokens, size_t &pos) {
    if (pos < tokens.size() && tokens[pos].type == Token::num)
    {
        return make_unique<NumExpr>(tokens[pos++].n);
    }
    else
    {
        return unique_ptr<Expr>();
    }
}

unique_ptr<Expr> parseVar(const vector<Token> &tokens, size_t &pos) {
    if (pos < tokens.size() && tokens[pos].type == Token::var)
    {
        return make_unique<VarExpr>(tokens[pos++].name);
    }
    else
    {
        return unique_ptr<Expr>();
    }
}

unique_ptr<Expr> parseSimExpr(const vector<Token> &tokens, size_t &pos)
{
    size_t bak = pos;

    if (pos < tokens.size() && tokens[pos].type == Token::left_p)
    {
        unique_ptr<Expr> res = parseAddExpr(tokens, ++pos);
        if (res && pos < tokens.size() && tokens[pos].type == Token::right_p)
        {
            pos++;
            return res;
        }
    }

    pos = bak;
    unique_ptr<Expr> v = parseVar(tokens, pos);
    if (v) return move(v);
    else return parseNum(tokens, pos);
}

unique_ptr<Expr> parseStatement(const vector<Token> &tokens, size_t &pos);
unique_ptr<Expr> parseProg(const vector<Token> &tokens, size_t &pos) {
    unique_ptr<Expr> left = parseStatement(tokens, pos);
    size_t bak = pos;
    if (!left) return unique_ptr<Expr>();
    if (pos < tokens.size() && tokens[pos].type == Token::semicolon) {
        unique_ptr<Expr> right = parseProg(tokens, ++pos);
        if (right) return make_unique<ProgExpr>(move(left), move(right));
    }
    pos = bak;
    return left;
}

unique_ptr<Expr> parseStatement(const vector<Token> &tokens, size_t &pos)
{
    size_t bak = pos;

    if (pos < tokens.size() && tokens[pos].type == Token::input)
    {
        pos++;
        if (pos < tokens.size() && tokens[pos].type == Token::var) {
            return make_unique<InputExpr>(tokens[pos++].name);
        }
    }
    pos = bak;
    if (pos < tokens.size() && tokens[pos].type == Token::output)
    {
        pos++;
        unique_ptr<Expr> p = parseExp(tokens, pos);
        if (p)
        {
            return make_unique<OutputExpr>(move(p));
        }
    }

    pos = bak;
    if (pos < tokens.size() && tokens[pos].type == Token::var)
    {
        string name = tokens[pos++].name;
        if (pos < tokens.size() && tokens[pos].type == Token::assign)
        {
            pos++;
            unique_ptr<Expr> p = parseExp(tokens, pos);
            if (p)
            {
                return make_unique<AssignExpr>(name, move(p));
            }
        }
    }
   
    pos = bak;

    return nullptr;
}

unique_ptr<Expr> parseAddExpr(const vector<Token> &tokens, size_t &pos) {
    unique_ptr<Expr> left = parseMultExpr(tokens, pos);
    size_t bak = pos;
    if (!left) return unique_ptr<Expr>();
    if (pos < tokens.size() && tokens[pos].type == Token::plus) {
        unique_ptr<Expr> right = parseAddExpr(tokens, ++pos);
        if (right) return make_unique<AddExpr>(move(left), move(right));
    }
    pos = bak;
    return left;
}

unique_ptr<Expr> parseMultExpr(const vector<Token> &tokens, size_t &pos) {
    unique_ptr<Expr> left = parseSimExpr(tokens, pos);
    size_t bak = pos;
    if (!left) return unique_ptr<Expr>();
    if (pos < tokens.size() && tokens[pos].type == Token::mult) {
        unique_ptr<Expr> right = parseMultExpr(tokens, ++pos);
        if (right) return make_unique<MulExpr>(move(left), move(right));
    }
    pos = bak;
    return left;
}

int main()
{
    size_t p = 0;

    auto tokens = tokenize(cin);
    auto e = parseProg(tokens, p);

    scope s;
    std::cout << e->eval(s) << std::endl;
    std::cout << p << std::endl;
}