#include <iostream>
#include <string>
#include <sstream>
#include <cctype>
#include <map>
#include <fstream>

using namespace std;

// Wyrażenia //////////////////////////////////////////////////////

typedef map<string, int> Memory;

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

class Constant : public Expression
{
    int value;

  public:
    Constant(int v) : value(v) {}

    virtual int eval(Memory& m)
    {
      return value;
    }
};

class Unknown_operator { };

class Binary_operator : public Expression
{
    char symbol;
    Expression* left, * right;

  public:
    Binary_operator(char s, Expression* l, Expression* r)
      : symbol(s), left(l), right(r) {}

    virtual int eval(Memory& m)
    {
      switch (symbol)
      {
        case '*': return left->eval(m) * right->eval(m);
        case '+': return left->eval(m) + right->eval(m);
        case '-': return left->eval(m) - right->eval(m);
        case '/': return left->eval(m) / right->eval(m);
        case '%': return left->eval(m) % right->eval(m);
        default : throw Unknown_operator();
      }
    }
};

class Variable_not_found { };

class Variable : public Expression
{
    string name;

  public:
    Variable(string n) : name(n) { }
  
    virtual int eval(Memory& m)
    {
      Memory::iterator it = m.find(name);
      if (it == m.end())
        throw Variable_not_found();
      return it->second;
    }
};

// Język programowania /////////////////////////////////////////////

class Program
{
  public:
    virtual void eval(Memory& m) = 0;
};

class Read : public Program
{
    string var;

  public:
    Read(string v) : var(v) { }

    virtual void eval(Memory& m)
    {
      int n;
      cin >> n;
      m[var] = n;
    }
};

class Write : public Program
{
    string var;

  public:
    Write(string v) : var(v) { }

    virtual void eval(Memory& m)
    {
      Memory::iterator it = m.find(var);
      if (it == m.end())
        throw Variable_not_found();
      cout << m[var] << endl;
    }
};

class Assign : public Program
{
    string var;
    Expression* expr;

  public:
    Assign(string v, Expression* e) : var(v), expr(e) { }

    virtual void eval(Memory& m)
    {
      m[var] = expr->eval(m);
    }
};

class Skip : public Program
{
  public:
    virtual void eval(Memory& m) { }
};

class Composition : public Program
{
    Program* left, * right;

  public:
    Composition(Program* l, Program* r) : left(l), right(r) { }

    virtual void eval(Memory& m)
    {
      left->eval(m);
      right->eval(m);
    }
};

class If : public Program
{
    Program* branch_then, * branch_else;
    Expression* condition;

  public:
    If(Expression* c, Program* t, Program* e)
      : condition(c), branch_then(t), branch_else(e) { }

    virtual void eval(Memory& m)
    {
      if (condition->eval(m) != 0)
        branch_then->eval(m);
      else
        branch_else->eval(m);
    }
};

class While : public Program
{
    Program *body;
    Expression* condition;

  public:
    While(Expression* c, Program* b)
      : condition(c), body(b) { }

    virtual void eval(Memory& m)
    {
      if (condition->eval(m) != 0)
      {
        body->eval(m);
        this->eval(m);
      }
    }
};


// Main /////////////////////////////////////////////////////////////

int main()
{
  /*
  int i = 0
  while 10 - i
    write i
    i = i + 1
  */

  Program* p = new Composition(
    new Assign("i", new Constant(0)),
    new While(new Binary_operator('-', new Constant(10), new Variable("i")),
      new Composition(
        new Write("i"),
        new Assign("i", new Binary_operator('+', new Variable("i"), new Constant(1)))
      )
    )
  );

  Memory m;
  p->eval(m);

  return 0;
}