public class Log {
  public static int err = 0;
  public static void pError(String s) { System.out.println(s); ++err; }
  public static int getError() { return err; }
}

import java.util.*;

public class Symtab {
  public static final int ITYPE = 1, ATYPE = 2, UNDEF = -1;
  List<Ent> tbl = new ArrayList<Ent>();
  Stack<Integer> stk = new Stack<Integer>();
  int mark;

  private boolean duplCheck(String n) {
    for(int i = mark; i < tbl.size(); ++i) {
      Ent e = tbl.get(i);
      if(e.alive && e.name.equals(n)) { return true; }
    }
    return false;
  }
  public Ent addDef(String n, int t) {
    if(duplCheck(n)) {
      Log.pError("dublicate: "+n); return new Ent(n, UNDEF, 0);
    }
    Ent e = new Ent(n, t, tbl.size()); tbl.add(e); return e;
  }
  public void enterScope() { stk.push(mark); mark = tbl.size(); }
  public void exitScope() {
    for(int i = mark; i < tbl.size(); ++i) { tbl.get(i).alive = false; }
    mark = stk.pop();
  }
  public Ent lookup(String n) {
    for(int i = tbl.size()-1; i >= 0; --i) {
      Ent e = tbl.get(i);
      if(e.alive && e.name.equals(n)) { return e; }
    }
    return new Ent(n, UNDEF, 0);
  }
  public int getGsize() { return tbl.size(); }
  public void show() { for(Ent e: tbl) { System.out.println(" " + e); } }
  public static class Ent {
    public String name;
    public boolean alive = true;
    public int type, pos = 0;
    public Ent(String n, int t, int p) { name = n; type = t; pos = p; }
    public String toString() {
      return String.format("%s%s[%d %d]", name, alive?"_":"!", type, pos);
    }
  }
}

import java.util.*;

public class SamA1 {
  public static void main(String[] args) throws Exception {
    Symtab st = new Symtab();
    Scanner sc = new Scanner(System.in);
    while(true) {
      System.out.print("> ");
      String[] cmd = sc.nextLine().split(" +");
      if(cmd[0].equals("quit")) {
        System.exit(0);
      } else if(cmd[0].equals("def")) {
        System.out.println(" +> " + st.addDef(cmd[1], Symtab.ITYPE));
      } else if(cmd[0].equals("ref")) {
        System.out.println(" -> " + st.lookup(cmd[1]));
      } else if(cmd[0].equals("enter")) {
        st.enterScope();
      } else if(cmd[0].equals("exit")) {
        st.exitScope();
      } else {
        st.show();
      }
    }
  }
}

Package sama2;

Helpers
  digit = ['0'..'9'] ;
  lcase = ['a'..'z'] ;
  ucase = ['A'..'Z'] ;
  letter = lcase | ucase ;

Tokens
  iconst = digit+ ;
  blank = (' '|13|10)+ ;
  int = 'int' ;
  if = 'if' ;
  while = 'while' ;
  read = 'read' ;
  print = 'print' ;
  semi = ';' ;
  assign = '=' ;
  add = '+' ;
  sub = '-' ;
  aster = '*' ;
  slash = '/' ;
  lt = '<' ;
  gt = '>' ;
  lbra = '{' ;
  rbra = '}' ;
  lpar = '(' ;
  rpar = ')' ;
  lsbr = '[' ;
  rsbr = ']' ;
  ident = letter (letter|digit)* ;

Ignored Tokens
  blank;

Productions
  prog = {stlist} stlist
       ;
  stlist = {stat} stlist stat
         | {empty}
         ;
  stat = {idcl}    int ident semi
       | {adcl}    int ident lsbr iconst rsbr semi
       | {assign}  ident assign expr semi
       | {aassign} ident lsbr [idx]:expr rsbr assign expr semi
       | {read}    read ident semi
       | {print}   print expr semi
       | {if}      if lpar expr rpar stat
       | {while}   while lpar expr rpar stat
       | {block}   lbra stlist rbra
       ;
  expr = {gt}  [left]:nexp gt [right]:nexp
       | {lt}  [left]:nexp lt [right]:nexp
       | {one} nexp
       ;
  nexp = {add}  nexp add term
       | {sub}  nexp sub term
       | {one}  term
       ;
  term = {mul}  term aster fact
       | {div}  term slash fact
       | {one}  fact
       ;
  fact = {iconst} iconst
       | {ident}  ident
       | {aref}   ident lsbr expr rsbr
       | {one}    lpar expr rpar
       ;

package sama2;
import sama2.analysis.*;
import sama2.node.*;
import java.io.*;
import java.util.*;

class TypeChecker extends DepthFirstAdapter {
  Symtab st;
  HashMap<Node,Integer> vtbl;
  public TypeChecker(Symtab tb, HashMap<Node,Integer> vt) { st = tb; vtbl = vt; }
  private void ckv(Node n, int t, int l, String s) {
    if(getOut(n) instanceof Integer && (Integer)getOut(n) == t) { return; }
    Log.pError(l+": "+s);
  }
  private int cki(String i, int t, int l) {
    Symtab.Ent e = st.lookup(i);
    if(e.type != t) { Log.pError(l+": identyfier is not of expexted type: "+i); }
    return e.pos;
  }
  @Override
  public void outAIdclStat(AIdclStat node) {
    st.addDef(node.getIdent().getText(), Symtab.ITYPE);
  }
  @Override
  public void outAAdclStat(AAdclStat node) {
    Symtab.Ent e = st.addDef(node.getIdent().getText(), Symtab.ATYPE);
    vtbl.put(node, e.pos);
  }
  @Override
  public void outAAssignStat(AAssignStat node) {
    int p = cki(node.getIdent().getText(), Symtab.ITYPE, node.getIdent().getLine());
    ckv(node.getExpr(), Symtab.ITYPE, node.getAssign().getLine(), "non-int val");
    vtbl.put(node, p);
  }
  @Override
  public void outAAassignStat(AAassignStat node) {
    int p = cki(node.getIdent().getText(), Symtab.ATYPE, node.getIdent().getLine());
    ckv(node.getIdx(), Symtab.ITYPE, node.getLsbr().getLine(), "non-int index");
    ckv(node.getExpr(), Symtab.ITYPE, node.getAssign().getLine(), "non-int val");
    vtbl.put(node, p);
  }
  @Override
  public void outAReadStat(AReadStat node) {
    int p = cki(node.getIdent().getText(), Symtab.ITYPE, node.getIdent().getLine());
    vtbl.put(node, p);
  }
  @Override
  public void outAPrintStat(APrintStat node) {
    ckv(node.getExpr(), Symtab.ITYPE, node.getPrint().getLine(), "non-int val");
  }
  @Override
  public void outAIfStat(AIfStat node) {
    ckv(node.getExpr(), Symtab.ITYPE, node.getLpar().getLine(), "non-int cond");
  }
  @Override
  public void outAWhileStat(AWhileStat node) {
    ckv(node.getExpr(), Symtab.ITYPE, node.getLpar().getLine(), "non-int cond");
  }
  @Override
  public void inABlockStat(ABlockStat node) { st.enterScope(); }
  @Override
  public void outABlockStat(ABlockStat node) { st.exitScope(); }
  @Override
  public void outAGtExpr(AGtExpr node) {
    ckv(node.getLeft(), Symtab.ITYPE, node.getGt().getLine(), "non-int val");
    ckv(node.getRight(), Symtab.ITYPE, node.getGt().getLine(), "non-int val");
    setOut(node, new Integer(Symtab.ITYPE));
  }
  @Override
  public void outALtExpr(ALtExpr node) {
    ckv(node.getLeft(), Symtab.ITYPE, node.getLt().getLine(), "non-int val");
    ckv(node.getRight(), Symtab.ITYPE, node.getLt().getLine(), "non-int val");
    setOut(node, new Integer(Symtab.ITYPE));
  }
  @Override
  public void outAOneExpr(AOneExpr node) { setOut(node, getOut(node.getNexp())); }
  @Override
  public void outAAddNexp(AAddNexp node) {
    ckv(node.getNexp(), Symtab.ITYPE, node.getAdd().getLine(), "non-int val");
    ckv(node.getTerm(), Symtab.ITYPE, node.getAdd().getLine(), "non-int val");
    setOut(node, new Integer(Symtab.ITYPE));
  }
  @Override
  public void outASubNexp(ASubNexp node) {
    ckv(node.getNexp(), Symtab.ITYPE, node.getSub().getLine(), "non-int val");
    ckv(node.getTerm(), Symtab.ITYPE, node.getSub().getLine(), "non-int val");
    setOut(node, new Integer(Symtab.ITYPE));
  }
  @Override
  public void outAOneNexp(AOneNexp node) { setOut(node, getOut(node.getTerm())); }
  @Override
  public void outAMulTerm(AMulTerm node) {
    ckv(node.getTerm(), Symtab.ITYPE, node.getAster().getLine(), "non-int val");
    ckv(node.getFact(), Symtab.ITYPE, node.getAster().getLine(), "non-int val");
    setOut(node, new Integer(Symtab.ITYPE));
  }
  @Override
  public void outADivTerm(ADivTerm node) {
    ckv(node.getTerm(), Symtab.ITYPE, node.getSlash().getLine(), "non-int val");
    ckv(node.getFact(), Symtab.ITYPE, node.getSlash().getLine(), "non-int val");
    setOut(node, new Integer(Symtab.ITYPE));
  }
  @Override
  public void outAOneTerm(AOneTerm node) { setOut(node, getOut(node.getFact())); }
  @Override
  public void outAIconstFact(AIconstFact node) {
    setOut(node, new Integer(Symtab.ITYPE));
  }
  @Override
  public void outAIdentFact(AIdentFact node) {
    Symtab.Ent e = st.lookup(node.getIdent().getText());
    setOut(node, new Integer(e.type)); vtbl.put(node, e.pos);
  }
  @Override
  public void outAArefFact(AArefFact node) {
    int p = cki(node.getIdent().getText(), Symtab.ATYPE, node.getIdent().getLine());
    ckv(node.getExpr(), Symtab.ITYPE, node.getLsbr().getLine(), "non-int index");
    setOut(node, new Integer(Symtab.ITYPE)); vtbl.put(node, p);
  }
  @Override
  public void outAOneFact(AOneFact node) { setOut(node, getOut(node.getExpr())); }
}

package sama2;
import sama2.parser.*;
import sama2.lexer.*;
import sama2.node.*;
import java.io.*;
import java.util.*;

public class SamA2 {
  public static void main(String[] args) throws Exception {
    Parser p = new Parser(new Lexer(new PushbackReader(
      new InputStreamReader(new FileInputStream(args[0]), "JISAutoDetect"),
        1024)));
    Start tree = p.parse();
    Symtab st = new Symtab();
    HashMap<Node,Integer> vtbl = new HashMap<Node,Integer>();
    TypeChecker tck = new TypeChecker(st, vtbl); tree.apply(tck); st.show();
//    if(Log.getError() > 0) { return; }
//    Executor exec = new Executor(vtbl, st.getGsize()); tree.apply(exec);
  }
}
class Log {
  public static int err = 0;
  public static void pError(String s) { System.out.println(s); ++err; }
  public static int getError() { return err; }
}
class Symtab {
  public static final int ITYPE = 1, ATYPE = 2, UNDEF = -1;
  List<Ent> tbl = new ArrayList<Ent>();
  Stack<Integer> stk = new Stack<Integer>();
  int mark;

  private boolean duplCheck(String n) {
    for(int i = mark; i < tbl.size(); ++i) {
      Ent e = tbl.get(i);
      if(e.alive && e.name.equals(n)) { return true; }
    }
    return false;
  }
  public Ent addDef(String n, int t) {
    if(duplCheck(n)) {
      Log.pError("dublicate: "+n); return new Ent(n, UNDEF, 0);
    }
    Ent e = new Ent(n, t, tbl.size()); tbl.add(e); return e;
  }
  public void enterScope() { stk.push(mark); mark = tbl.size(); }
  public void exitScope() {
    for(int i = mark; i < tbl.size(); ++i) { tbl.get(i).alive = false; }
    mark = stk.pop();
  }
  public Ent lookup(String n) {
    for(int i = tbl.size()-1; i >= 0; --i) {
      Ent e = tbl.get(i);
      if(e.alive && e.name.equals(n)) { return e; }
    }
    return new Ent(n, UNDEF, 0);
  }
  public int getGsize() { return tbl.size(); }
  public void show() { for(Ent e: tbl) { System.out.println(" " + e); } }
  public static class Ent {
    public String name;
    public boolean alive = true;
    public int type, pos = 0;
    public Ent(String n, int t, int p) { name = n; type = t; pos = p; }
    public String toString() {
      return String.format("%s%s[%d %d]", name, alive?"_":"!", type, pos);
    }
  }
}

package sama2;
import sama2.analysis.*;
import sama2.node.*;
import java.io.*;
import java.util.*;

class Executor extends DepthFirstAdapter {
  Scanner sc = new Scanner(System.in);
  PrintStream pr = System.out;
  HashMap<Node,Integer> pos;
  Object[] vars;
  public Executor(HashMap<Node,Integer> p, int s) { pos = p; vars = new Object[s]; }
  @Override
  public void outAAdclStat(AAdclStat node) {
    vars[pos.get(node)] = new Object[Integer.parseInt(node.getIconst().getText())];
  }
  @Override
  public void outAAssignStat(AAssignStat node) {
    vars[pos.get(node)] = getOut(node.getExpr());
  }
  @Override
  public void outAAassignStat(AAassignStat node) {
    Object[] a = (Object[])vars[pos.get(node)];
    a[(Integer)getOut(node.getIdx())] = getOut(node.getExpr());
  }
  @Override
  public void outAReadStat(AReadStat node) {
    String s = node.getIdent().getText().intern();
    pr.print(s + "> "); vars[pos.get(node)] = sc.nextInt(); sc.nextLine();
  }
  @Override
  public void outAPrintStat(APrintStat node) {
    pr.println(getOut(node.getExpr()).toString());
  }
  @Override
  public void caseAIfStat(AIfStat node) {
    node.getExpr().apply(this);
    if((Integer)getOut(node.getExpr()) != 0) { node.getStat().apply(this); }
  }
  @Override
  public void caseAWhileStat(AWhileStat node) {
    while(true) {
      node.getExpr().apply(this);
      if((Integer)getOut(node.getExpr()) == 0) { return; }
      node.getStat().apply(this);
    }
  }
  @Override
  public void outAGtExpr(AGtExpr node) {
    if((Integer)getOut(node.getLeft()) > (Integer)getOut(node.getRight())) {
      setOut(node, new Integer(1));
    } else {
      setOut(node, new Integer(0));
    }
  }
  @Override
  public void outALtExpr(ALtExpr node) {
    if((Integer)getOut(node.getLeft()) < (Integer)getOut(node.getRight())) {
      setOut(node, new Integer(1));
    } else {
      setOut(node, new Integer(0));
    }
  }
  @Override
  public void outAOneExpr(AOneExpr node) { setOut(node, getOut(node.getNexp())); }
  @Override
  public void outAAddNexp(AAddNexp node) {
    int v = (Integer)getOut(node.getNexp()) + (Integer)getOut(node.getTerm());
    setOut(node, new Integer(v));
  }  
  @Override
  public void outASubNexp(ASubNexp node) {
    int v = (Integer)getOut(node.getNexp()) - (Integer)getOut(node.getTerm());
    setOut(node, new Integer(v));
  }
  @Override
  public void outAOneNexp(AOneNexp node) { setOut(node, getOut(node.getTerm())); }
  @Override
  public void outAMulTerm(AMulTerm node) {
    int v = (Integer)getOut(node.getTerm()) * (Integer)getOut(node.getFact());
    setOut(node, new Integer(v));
  }  
  @Override
  public void outADivTerm(ADivTerm node) {
    int v = (Integer)getOut(node.getTerm()) / (Integer)getOut(node.getFact());
    setOut(node, new Integer(v));
  }
  @Override
  public void outAOneTerm(AOneTerm node) { setOut(node, getOut(node.getFact())); }
  @Override
  public void outAIconstFact(AIconstFact node) {
    setOut(node, new Integer(node.getIconst().getText()));
  }
  @Override
  public void outAIdentFact(AIdentFact node) {
    setOut(node, vars[pos.get(node)]);
  }
  @Override
  public void outAArefFact(AArefFact node) {
    Object[] a = (Object[])vars[pos.get(node)];
    setOut(node, a[(Integer)getOut(node.getExpr())]);
  }
  @Override
  public void outAOneFact(AOneFact node) { setOut(node, getOut(node.getExpr())); }
}

int a[100]; int n; int i; int d;
read n;
i = 0; while(i < n) { read d; a[i] = d; i = i + 1; }
i = n - 1; while(i > 0-1) { print a[i]; i = i - 1; }