#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(const string & id) :
		id(id)
	{}

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

	string getId() {
		return 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>(dynamic_cast<VarExpr*>(r.get())->getId());
	}
	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>(dynamic_cast<VarExpr*>(l.get())->getId(), 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_prog_exp(t, nula);
	Scope s;


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

}