/* Generated By:JJTree&JavaCC: Do not edit this line. MiniJaja.java */
package minijaja.parseur;

import minijaja.ast_struct.*;


public class MiniJaja/*@bgen(jjtree)*/implements MiniJajaTreeConstants, MiniJajaConstants {/*@bgen(jjtree)*/
        	
	protected static JJTMiniJajaState jjtree = new JJTMiniJajaState();
        	
                public static void main (String arg[]) throws ParseException {
                        MiniJaja mjj = new MiniJaja(System.in) ;
                        mjj.axiome() ;
                }
                
/**
 * Revoie la valeur du membre jjtree.
 */
public static JJTMiniJajaState getJjtree() {
	return jjtree;
}


/**
 * Affecte une nouvelle valeur au membre jjtree.
 */
public static void setJjtree(JJTMiniJajaState jjtree) {
	MiniJaja.jjtree = jjtree;
}            
                    

/* -------------------- Grammaire  ------------------------- */
                
  
static final public void axiome() throws ParseException {
    trace_call("axiome");
    try {
               /*@bgen(jjtree) axiome */
  ASTaxiome jjtn000 = new ASTaxiome(JJTAXIOME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
      try {
        classe();
        jj_consume_token(0);
      } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
      } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
      }
    } finally {
      trace_return("axiome");
    }
  }

  static final public void ident() throws ParseException {
    trace_call("ident");
    try {
                     /*@bgen(jjtree) ident */
  ASTident jjtn000 = new ASTident(JJTIDENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(IDENTIFIER);
                      jjtree.closeNodeScope(jjtn000, true);
                      jjtc000 = false;
                     jjtn000.setValeur(token.image);
      } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
      }
    } finally {
      trace_return("ident");
    }
  }

  static final public void nbre() throws ParseException {
    trace_call("nbre");
    try {
                   /*@bgen(jjtree) nbre */
                   ASTnbre jjtn000 = new ASTnbre(JJTNBRE);
                   boolean jjtc000 = true;
                   jjtree.openNodeScope(jjtn000);int x;
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NUMBER:
          jj_consume_token(NUMBER);
          break;
        case INTEGER_LITERAL:
          jj_consume_token(INTEGER_LITERAL);
          break;
        default:
          jj_la1[0] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
                                   jjtree.closeNodeScope(jjtn000, true);
                                   jjtc000 = false;
                try { x = Integer.parseInt(token.image);
                } catch (NumberFormatException ee) {
                   System.err.println("Erreur : " + token.image + " n'est pas un nombre representable.");
                   x = 0;
                }
                jjtn000.setValeur(x);
      } finally {
   if (jjtc000) {
     jjtree.closeNodeScope(jjtn000, true);
   }
      }
    } finally {
      trace_return("nbre");
    }
  }

  static final public void classe() throws ParseException {
    trace_call("classe");
    try {
                       /*@bgen(jjtree) classe */
  ASTclasse jjtn000 = new ASTclasse(JJTCLASSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(CLASS);
        ident();
        jj_consume_token(LBRACE);
        decls();
        methmain();
        jj_consume_token(RBRACE);
      } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
      } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
      }
    } finally {
      trace_return("classe");
    }
  }

  static final public void ident2() throws ParseException {
    trace_call("ident2");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
        jj_consume_token(LBRACKET);
        exp();
                   ASTtableau jjtn001 = new ASTtableau(JJTTABLEAU);
                   boolean jjtc001 = true;
                   jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(RBRACKET);
        } finally {
                   if (jjtc001) {
                     jjtree.closeNodeScope(jjtn001, true);
                   }
        }
        break;
      default:
        jj_la1[1] = jj_gen;
        vide();
      }
    } finally {
      trace_return("ident2");
    }
  }

  static final public void typemeth() throws ParseException {
    trace_call("typemeth");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case INT:
        type();
        break;
      case VOID:
      ASTrien jjtn001 = new ASTrien(JJTRIEN);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(VOID);
        } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
        }
        break;
      default:
        jj_la1[2] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("typemeth");
    }
  }

  static final public void type() throws ParseException {
    trace_call("type");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INT:
    ASTentier jjtn001 = new ASTentier(JJTENTIER);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(INT);
        } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001, true);
    }
        }
        break;
      case BOOLEAN:
      ASTbooleen jjtn002 = new ASTbooleen(JJTBOOLEEN);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(BOOLEAN);
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
        break;
      default:
        jj_la1[3] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("type");
    }
  }

  static final public void decls() throws ParseException {
    trace_call("decls");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case FINAL:
      case INT:
      case VOID:
        decl();
        jj_consume_token(SEMICOLON);
                     ASTdecls jjtn001 = new ASTdecls(JJTDECLS);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
        try {
          decls();
        } catch (Throwable jjte001) {
                     if (jjtc001) {
                       jjtree.clearNodeScope(jjtn001);
                       jjtc001 = false;
                     } else {
                       jjtree.popNode();
                     }
                     if (jjte001 instanceof RuntimeException) {
                       {if (true) throw (RuntimeException)jjte001;}
                     }
                     if (jjte001 instanceof ParseException) {
                       {if (true) throw (ParseException)jjte001;}
                     }
                     {if (true) throw (Error)jjte001;}
        } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001, true);
                     }
        }
        break;
      default:
        jj_la1[4] = jj_gen;
      ASTvnil jjtn002 = new ASTvnil(JJTVNIL);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          vide();
        } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
      }
    } finally {
      trace_return("decls");
    }
  }

  static final public void decl() throws ParseException {
    trace_call("decl");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case INT:
      case VOID:
        typemeth();
        ident();
        decl2();
        break;
      case FINAL:
        jj_consume_token(FINAL);
        type();
        jj_consume_token(IDENTIFIER);
                               ASTcst jjtn001 = new ASTcst(JJTCST);
                               boolean jjtc001 = true;
                               jjtree.openNodeScope(jjtn001);
        try {
          vexp();
        } catch (Throwable jjte001) {
                               if (jjtc001) {
                                 jjtree.clearNodeScope(jjtn001);
                                 jjtc001 = false;
                               } else {
                                 jjtree.popNode();
                               }
                               if (jjte001 instanceof RuntimeException) {
                                 {if (true) throw (RuntimeException)jjte001;}
                               }
                               if (jjte001 instanceof ParseException) {
                                 {if (true) throw (ParseException)jjte001;}
                               }
                               {if (true) throw (Error)jjte001;}
        } finally {
                               if (jjtc001) {
                                 jjtree.closeNodeScope(jjtn001, true);
                               }
        }
        break;
      default:
        jj_la1[5] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("decl");
    }
  }

  static final public void decl2() throws ParseException {
    trace_call("decl2");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
    ASTtableau jjtn001 = new ASTtableau(JJTTABLEAU);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(LBRACKET);
          exp();
          jj_consume_token(RBRACKET);
        } catch (Throwable jjte001) {
    if (jjtc001) {
      jjtree.clearNodeScope(jjtn001);
      jjtc001 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte001 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte001;}
    }
    if (jjte001 instanceof ParseException) {
      {if (true) throw (ParseException)jjte001;}
    }
    {if (true) throw (Error)jjte001;}
        } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001, true);
    }
        }
        break;
      case LPAREN:
      ASTmethode jjtn002 = new ASTmethode(JJTMETHODE);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(LPAREN);
          entetes();
          jj_consume_token(RPAREN);
          jj_consume_token(LBRACE);
          vars();
          instrs();
          jj_consume_token(RBRACE);
        } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
        break;
      default:
        jj_la1[6] = jj_gen;
       ASTvar jjtn003 = new ASTvar(JJTVAR);
       boolean jjtc003 = true;
       jjtree.openNodeScope(jjtn003);
        try {
          vexp();
        } catch (Throwable jjte003) {
       if (jjtc003) {
         jjtree.clearNodeScope(jjtn003);
         jjtc003 = false;
       } else {
         jjtree.popNode();
       }
       if (jjte003 instanceof RuntimeException) {
         {if (true) throw (RuntimeException)jjte003;}
       }
       if (jjte003 instanceof ParseException) {
         {if (true) throw (ParseException)jjte003;}
       }
       {if (true) throw (Error)jjte003;}
        } finally {
       if (jjtc003) {
         jjtree.closeNodeScope(jjtn003, true);
       }
        }
      }
    } finally {
      trace_return("decl2");
    }
  }

  static final public void vars() throws ParseException {
    trace_call("vars");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case FINAL:
      case INT:
      case VOID:
        var();
        jj_consume_token(SEMICOLON);
                    ASTvars jjtn001 = new ASTvars(JJTVARS);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
        try {
          vars();
        } catch (Throwable jjte001) {
                    if (jjtc001) {
                      jjtree.clearNodeScope(jjtn001);
                      jjtc001 = false;
                    } else {
                      jjtree.popNode();
                    }
                    if (jjte001 instanceof RuntimeException) {
                      {if (true) throw (RuntimeException)jjte001;}
                    }
                    if (jjte001 instanceof ParseException) {
                      {if (true) throw (ParseException)jjte001;}
                    }
                    {if (true) throw (Error)jjte001;}
        } finally {
                    if (jjtc001) {
                      jjtree.closeNodeScope(jjtn001, true);
                    }
        }
        break;
      default:
        jj_la1[7] = jj_gen;
      ASTvnil jjtn002 = new ASTvnil(JJTVNIL);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          vide();
        } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
      }
    } finally {
      trace_return("vars");
    }
  }

  static final public void var() throws ParseException {
    trace_call("var");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case INT:
      case VOID:
        typemeth();
        ident();
                     ASTvoid jjtn001 = new ASTvoid(JJTVOID);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
        try {
          var2();
        } catch (Throwable jjte001) {
                     if (jjtc001) {
                       jjtree.clearNodeScope(jjtn001);
                       jjtc001 = false;
                     } else {
                       jjtree.popNode();
                     }
                     if (jjte001 instanceof RuntimeException) {
                       {if (true) throw (RuntimeException)jjte001;}
                     }
                     if (jjte001 instanceof ParseException) {
                       {if (true) throw (ParseException)jjte001;}
                     }
                     {if (true) throw (Error)jjte001;}
        } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001, true);
                     }
        }
        break;
      case FINAL:
        jj_consume_token(FINAL);
        type();
        ident();
                          ASTcst jjtn002 = new ASTcst(JJTCST);
                          boolean jjtc002 = true;
                          jjtree.openNodeScope(jjtn002);
        try {
          vexp();
        } catch (Throwable jjte002) {
                          if (jjtc002) {
                            jjtree.clearNodeScope(jjtn002);
                            jjtc002 = false;
                          } else {
                            jjtree.popNode();
                          }
                          if (jjte002 instanceof RuntimeException) {
                            {if (true) throw (RuntimeException)jjte002;}
                          }
                          if (jjte002 instanceof ParseException) {
                            {if (true) throw (ParseException)jjte002;}
                          }
                          {if (true) throw (Error)jjte002;}
        } finally {
                          if (jjtc002) {
                            jjtree.closeNodeScope(jjtn002, true);
                          }
        }
        break;
      default:
        jj_la1[8] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("var");
    }
  }

  static final public void var2() throws ParseException {
    trace_call("var2");
    try {
    ASTvar jjtn001 = new ASTvar(JJTVAR);
    boolean jjtc001 = true;
    jjtree.openNodeScope(jjtn001);
      try {
        vexp();
      } catch (Throwable jjte001) {
    if (jjtc001) {
      jjtree.clearNodeScope(jjtn001);
      jjtc001 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte001 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte001;}
    }
    if (jjte001 instanceof ParseException) {
      {if (true) throw (ParseException)jjte001;}
    }
    {if (true) throw (Error)jjte001;}
      } finally {
    if (jjtc001) {
      jjtree.closeNodeScope(jjtn001, true);
    }
      }
    } finally {
      trace_return("var2");
    }
  }

  static final public void vexp() throws ParseException {
    trace_call("vexp");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASSIGN:
        jj_consume_token(ASSIGN);
            ASTvoid jjtn001 = new ASTvoid(JJTVOID);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
        try {
          exp();
        } catch (Throwable jjte001) {
            if (jjtc001) {
              jjtree.clearNodeScope(jjtn001);
              jjtc001 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte001;}
            }
            if (jjte001 instanceof ParseException) {
              {if (true) throw (ParseException)jjte001;}
            }
            {if (true) throw (Error)jjte001;}
        } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001, true);
            }
        }
        break;
      default:
        jj_la1[9] = jj_gen;
      ASTomega jjtn002 = new ASTomega(JJTOMEGA);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          vide();
        } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
      }
    } finally {
      trace_return("vexp");
    }
  }

  static final public void methmain() throws ParseException {
    trace_call("methmain");
    try {
                       /*@bgen(jjtree) main */
  ASTmain jjtn000 = new ASTmain(JJTMAIN);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(MAIN);
        jj_consume_token(LBRACE);
        vars();
        instrs();
        jj_consume_token(RBRACE);
      } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
      } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
      }
    } finally {
      trace_return("methmain");
    }
  }

  static final public void entetes() throws ParseException {
    trace_call("entetes");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case INT:
        entete();
            ASTentetes jjtn001 = new ASTentetes(JJTENTETES);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
        try {
          entetes2();
        } catch (Throwable jjte001) {
            if (jjtc001) {
              jjtree.clearNodeScope(jjtn001);
              jjtc001 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte001;}
            }
            if (jjte001 instanceof ParseException) {
              {if (true) throw (ParseException)jjte001;}
            }
            {if (true) throw (Error)jjte001;}
        } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001, true);
            }
        }
        break;
      default:
        jj_la1[10] = jj_gen;
      ASTenil jjtn002 = new ASTenil(JJTENIL);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          vide();
        } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
      }
    } finally {
      trace_return("entetes");
    }
  }

  static final public void entetes2() throws ParseException {
    trace_call("entetes2");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        jj_consume_token(COMMA);
        entete();
        entetes2();
        break;
      default:
        jj_la1[11] = jj_gen;
        vide();
      }
    } finally {
      trace_return("entetes2");
    }
  }

  static final public void entete() throws ParseException {
    trace_call("entete");
    try {
                       /*@bgen(jjtree) entete */
  ASTentete jjtn000 = new ASTentete(JJTENTETE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
      try {
        type();
        ident();
      } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
      } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
      }
    } finally {
      trace_return("entete");
    }
  }

  static final public void instrs() throws ParseException {
    trace_call("instrs");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
      case RETURN:
      case WHILE:
      case IDENTIFIER:
        instr();
        jj_consume_token(SEMICOLON);
                      ASTinstrs jjtn001 = new ASTinstrs(JJTINSTRS);
                      boolean jjtc001 = true;
                      jjtree.openNodeScope(jjtn001);
        try {
          instrs();
        } catch (Throwable jjte001) {
                      if (jjtc001) {
                        jjtree.clearNodeScope(jjtn001);
                        jjtc001 = false;
                      } else {
                        jjtree.popNode();
                      }
                      if (jjte001 instanceof RuntimeException) {
                        {if (true) throw (RuntimeException)jjte001;}
                      }
                      if (jjte001 instanceof ParseException) {
                        {if (true) throw (ParseException)jjte001;}
                      }
                      {if (true) throw (Error)jjte001;}
        } finally {
                      if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001, true);
                      }
        }
        break;
      default:
        jj_la1[12] = jj_gen;
      ASTinil jjtn002 = new ASTinil(JJTINIL);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          vide();
        } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
      }
    } finally {
      trace_return("instrs");
    }
  }

  static final public void instr() throws ParseException {
    trace_call("instr");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IDENTIFIER:
        ident();
        instr2();
        break;
      case RETURN:
        jj_consume_token(RETURN);
              ASTretour jjtn001 = new ASTretour(JJTRETOUR);
              boolean jjtc001 = true;
              jjtree.openNodeScope(jjtn001);
        try {
          exp();
        } catch (Throwable jjte001) {
              if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
              } else {
                jjtree.popNode();
              }
              if (jjte001 instanceof RuntimeException) {
                {if (true) throw (RuntimeException)jjte001;}
              }
              if (jjte001 instanceof ParseException) {
                {if (true) throw (ParseException)jjte001;}
              }
              {if (true) throw (Error)jjte001;}
        } finally {
              if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, true);
              }
        }
        break;
      case WHILE:
        jj_consume_token(WHILE);
        jj_consume_token(LPAREN);
        exp();
        jj_consume_token(RPAREN);
        jj_consume_token(LBRACE);
        instrs();
                                                  ASTtantque jjtn002 = new ASTtantque(JJTTANTQUE);
                                                  boolean jjtc002 = true;
                                                  jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(RBRACE);
        } finally {
                                                  if (jjtc002) {
                                                    jjtree.closeNodeScope(jjtn002, true);
                                                  }
        }
        break;
      case IF:
        jj_consume_token(IF);
        jj_consume_token(LPAREN);
        exp();
        jj_consume_token(RPAREN);
        jj_consume_token(LBRACE);
        instrs();
        jj_consume_token(RBRACE);
                                                      ASTsi jjtn003 = new ASTsi(JJTSI);
                                                      boolean jjtc003 = true;
                                                      jjtree.openNodeScope(jjtn003);
        try {
          elseNode();
        } catch (Throwable jjte003) {
                                                      if (jjtc003) {
                                                        jjtree.clearNodeScope(jjtn003);
                                                        jjtc003 = false;
                                                      } else {
                                                        jjtree.popNode();
                                                      }
                                                      if (jjte003 instanceof RuntimeException) {
                                                        {if (true) throw (RuntimeException)jjte003;}
                                                      }
                                                      if (jjte003 instanceof ParseException) {
                                                        {if (true) throw (ParseException)jjte003;}
                                                      }
                                                      {if (true) throw (Error)jjte003;}
        } finally {
                                                      if (jjtc003) {
                                                        jjtree.closeNodeScope(jjtn003, true);
                                                      }
        }
        break;
      default:
        jj_la1[13] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("instr");
    }
  }

  static final public void elseNode() throws ParseException {
    trace_call("elseNode");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ELSE:
        jj_consume_token(ELSE);
        jj_consume_token(LBRACE);
        instrs();
        jj_consume_token(RBRACE);
        break;
      default:
        jj_la1[14] = jj_gen;
        vide();
      }
    } finally {
      trace_return("elseNode");
    }
  }

  static final public void instr2() throws ParseException {
    trace_call("instr2");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
      case ASSIGN:
      case INCR:
      case PLUSASSIGN:
        ident2();
        instr3();
        break;
      case LPAREN:
        jj_consume_token(LPAREN);
        listexp();
                       ASTappelI jjtn001 = new ASTappelI(JJTAPPELI);
                       boolean jjtc001 = true;
                       jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(RPAREN);
        } finally {
                       if (jjtc001) {
                         jjtree.closeNodeScope(jjtn001, true);
                       }
        }
        break;
      default:
        jj_la1[15] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("instr2");
    }
  }

  static final public void instr3() throws ParseException {
    trace_call("instr3");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASSIGN:
        jj_consume_token(ASSIGN);
            ASTaffectation jjtn001 = new ASTaffectation(JJTAFFECTATION);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
        try {
          exp();
        } catch (Throwable jjte001) {
            if (jjtc001) {
              jjtree.clearNodeScope(jjtn001);
              jjtc001 = false;
            } else {
              jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
              {if (true) throw (RuntimeException)jjte001;}
            }
            if (jjte001 instanceof ParseException) {
              {if (true) throw (ParseException)jjte001;}
            }
            {if (true) throw (Error)jjte001;}
        } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001, true);
            }
        }
        break;
      case PLUSASSIGN:
        jj_consume_token(PLUSASSIGN);
                  ASTsomme jjtn002 = new ASTsomme(JJTSOMME);
                  boolean jjtc002 = true;
                  jjtree.openNodeScope(jjtn002);
        try {
          exp();
        } catch (Throwable jjte002) {
                  if (jjtc002) {
                    jjtree.clearNodeScope(jjtn002);
                    jjtc002 = false;
                  } else {
                    jjtree.popNode();
                  }
                  if (jjte002 instanceof RuntimeException) {
                    {if (true) throw (RuntimeException)jjte002;}
                  }
                  if (jjte002 instanceof ParseException) {
                    {if (true) throw (ParseException)jjte002;}
                  }
                  {if (true) throw (Error)jjte002;}
        } finally {
                  if (jjtc002) {
                    jjtree.closeNodeScope(jjtn002, true);
                  }
        }
        break;
      case INCR:
      ASTincrement jjtn003 = new ASTincrement(JJTINCREMENT);
      boolean jjtc003 = true;
      jjtree.openNodeScope(jjtn003);
        try {
          jj_consume_token(INCR);
        } finally {
      if (jjtc003) {
        jjtree.closeNodeScope(jjtn003, true);
      }
        }
        break;
      default:
        jj_la1[16] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("instr3");
    }
  }

  static final public void listexp() throws ParseException {
    trace_call("listexp");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FALSE:
      case TRUE:
      case INTEGER_LITERAL:
      case LPAREN:
      case IDENTIFIER:
      case NUMBER:
      case BANG:
      case MINUS:
        exp();
        listexp2();
        break;
      default:
        jj_la1[17] = jj_gen;
      ASTexnil jjtn001 = new ASTexnil(JJTEXNIL);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001);
        try {
          vide();
        } catch (Throwable jjte001) {
      if (jjtc001) {
        jjtree.clearNodeScope(jjtn001);
        jjtc001 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte001 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte001;}
      }
      if (jjte001 instanceof ParseException) {
        {if (true) throw (ParseException)jjte001;}
      }
      {if (true) throw (Error)jjte001;}
        } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
        }
      }
    } finally {
      trace_return("listexp");
    }
  }

  static final public void listexp2() throws ParseException {
    trace_call("listexp2");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        jj_consume_token(COMMA);
        exp();
                ASTlistexp jjtn001 = new ASTlistexp(JJTLISTEXP);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
        try {
          listexp2();
        } catch (Throwable jjte001) {
                if (jjtc001) {
                  jjtree.clearNodeScope(jjtn001);
                  jjtc001 = false;
                } else {
                  jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                  {if (true) throw (RuntimeException)jjte001;}
                }
                if (jjte001 instanceof ParseException) {
                  {if (true) throw (ParseException)jjte001;}
                }
                {if (true) throw (Error)jjte001;}
        } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001, true);
                }
        }
        break;
      default:
        jj_la1[18] = jj_gen;
      ASTexnil jjtn002 = new ASTexnil(JJTEXNIL);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          vide();
        } catch (Throwable jjte002) {
      if (jjtc002) {
        jjtree.clearNodeScope(jjtn002);
        jjtc002 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte002 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte002;}
      }
      if (jjte002 instanceof ParseException) {
        {if (true) throw (ParseException)jjte002;}
      }
      {if (true) throw (Error)jjte002;}
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
      }
    } finally {
      trace_return("listexp2");
    }
  }

  static final public void exp() throws ParseException {
    trace_call("exp");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BANG:
        jj_consume_token(BANG);
          ASTnon jjtn001 = new ASTnon(JJTNON);
          boolean jjtc001 = true;
          jjtree.openNodeScope(jjtn001);
        try {
          exp1();
        } catch (Throwable jjte001) {
          if (jjtc001) {
            jjtree.clearNodeScope(jjtn001);
            jjtc001 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte001 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte001;}
          }
          if (jjte001 instanceof ParseException) {
            {if (true) throw (ParseException)jjte001;}
          }
          {if (true) throw (Error)jjte001;}
        } finally {
          if (jjtc001) {
            jjtree.closeNodeScope(jjtn001, true);
          }
        }
        break;
      case MINUS:
        jj_consume_token(MINUS);
             ASTmoins jjtn002 = new ASTmoins(JJTMOINS);
             boolean jjtc002 = true;
             jjtree.openNodeScope(jjtn002);
        try {
          exp1();
        } catch (Throwable jjte002) {
             if (jjtc002) {
               jjtree.clearNodeScope(jjtn002);
               jjtc002 = false;
             } else {
               jjtree.popNode();
             }
             if (jjte002 instanceof RuntimeException) {
               {if (true) throw (RuntimeException)jjte002;}
             }
             if (jjte002 instanceof ParseException) {
               {if (true) throw (ParseException)jjte002;}
             }
             {if (true) throw (Error)jjte002;}
        } finally {
             if (jjtc002) {
               jjtree.closeNodeScope(jjtn002, true);
             }
        }
        break;
      case FALSE:
      case TRUE:
      case INTEGER_LITERAL:
      case LPAREN:
      case IDENTIFIER:
      case NUMBER:
        exp1();
        expP();
        break;
      default:
        jj_la1[19] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("exp");
    }
  }

  static final public void expP() throws ParseException {
    trace_call("expP");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AND:
        jj_consume_token(AND);
        exp1();
               ASTet jjtn001 = new ASTet(JJTET);
               boolean jjtc001 = true;
               jjtree.openNodeScope(jjtn001);
        try {
          expP();
        } catch (Throwable jjte001) {
               if (jjtc001) {
                 jjtree.clearNodeScope(jjtn001);
                 jjtc001 = false;
               } else {
                 jjtree.popNode();
               }
               if (jjte001 instanceof RuntimeException) {
                 {if (true) throw (RuntimeException)jjte001;}
               }
               if (jjte001 instanceof ParseException) {
                 {if (true) throw (ParseException)jjte001;}
               }
               {if (true) throw (Error)jjte001;}
        } finally {
               if (jjtc001) {
                 jjtree.closeNodeScope(jjtn001, true);
               }
        }
        break;
      case OR:
        jj_consume_token(OR);
        exp1();
                ASTou jjtn002 = new ASTou(JJTOU);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
        try {
          expP();
        } catch (Throwable jjte002) {
                if (jjtc002) {
                  jjtree.clearNodeScope(jjtn002);
                  jjtc002 = false;
                } else {
                  jjtree.popNode();
                }
                if (jjte002 instanceof RuntimeException) {
                  {if (true) throw (RuntimeException)jjte002;}
                }
                if (jjte002 instanceof ParseException) {
                  {if (true) throw (ParseException)jjte002;}
                }
                {if (true) throw (Error)jjte002;}
        } finally {
                if (jjtc002) {
                  jjtree.closeNodeScope(jjtn002, true);
                }
        }
        break;
      default:
        jj_la1[20] = jj_gen;
        vide();
      }
    } finally {
      trace_return("expP");
    }
  }

  static final public void exp1() throws ParseException {
    trace_call("exp1");
    try {
      exp2();
      exp1P();
    } finally {
      trace_return("exp1");
    }
  }

  static final public void exp1P() throws ParseException {
    trace_call("exp1P");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        jj_consume_token(EQ);
        ASTegal jjtn001 = new ASTegal(JJTEGAL);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        try {
          exp2();
        } catch (Throwable jjte001) {
        if (jjtc001) {
          jjtree.clearNodeScope(jjtn001);
          jjtc001 = false;
        } else {
          jjtree.popNode();
        }
        if (jjte001 instanceof RuntimeException) {
          {if (true) throw (RuntimeException)jjte001;}
        }
        if (jjte001 instanceof ParseException) {
          {if (true) throw (ParseException)jjte001;}
        }
        {if (true) throw (Error)jjte001;}
        } finally {
        if (jjtc001) {
          jjtree.closeNodeScope(jjtn001, true);
        }
        }
        break;
      case LT:
        jj_consume_token(LT);
          ASTinf jjtn002 = new ASTinf(JJTINF);
          boolean jjtc002 = true;
          jjtree.openNodeScope(jjtn002);
        try {
          exp2();
        } catch (Throwable jjte002) {
          if (jjtc002) {
            jjtree.clearNodeScope(jjtn002);
            jjtc002 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte002 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte002;}
          }
          if (jjte002 instanceof ParseException) {
            {if (true) throw (ParseException)jjte002;}
          }
          {if (true) throw (Error)jjte002;}
        } finally {
          if (jjtc002) {
            jjtree.closeNodeScope(jjtn002, true);
          }
        }
        break;
      case GT:
        jj_consume_token(GT);
          ASTsup jjtn003 = new ASTsup(JJTSUP);
          boolean jjtc003 = true;
          jjtree.openNodeScope(jjtn003);
        try {
          exp2();
        } catch (Throwable jjte003) {
          if (jjtc003) {
            jjtree.clearNodeScope(jjtn003);
            jjtc003 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte003 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte003;}
          }
          if (jjte003 instanceof ParseException) {
            {if (true) throw (ParseException)jjte003;}
          }
          {if (true) throw (Error)jjte003;}
        } finally {
          if (jjtc003) {
            jjtree.closeNodeScope(jjtn003, true);
          }
        }
        break;
      default:
        jj_la1[21] = jj_gen;
        vide();
      }
    } finally {
      trace_return("exp1P");
    }
  }

  static final public void exp2() throws ParseException {
    trace_call("exp2");
    try {
      terme();
      exp2P();
    } finally {
      trace_return("exp2");
    }
  }

  static final public void exp2P() throws ParseException {
    trace_call("exp2P");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PLUS:
        jj_consume_token(PLUS);
          ASTplus jjtn001 = new ASTplus(JJTPLUS);
          boolean jjtc001 = true;
          jjtree.openNodeScope(jjtn001);
        try {
          exp2();
        } catch (Throwable jjte001) {
          if (jjtc001) {
            jjtree.clearNodeScope(jjtn001);
            jjtc001 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte001 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte001;}
          }
          if (jjte001 instanceof ParseException) {
            {if (true) throw (ParseException)jjte001;}
          }
          {if (true) throw (Error)jjte001;}
        } finally {
          if (jjtc001) {
            jjtree.closeNodeScope(jjtn001, true);
          }
        }
        break;
      case MINUS:
        jj_consume_token(MINUS);
             ASTmoins jjtn002 = new ASTmoins(JJTMOINS);
             boolean jjtc002 = true;
             jjtree.openNodeScope(jjtn002);
        try {
          exp2();
        } catch (Throwable jjte002) {
             if (jjtc002) {
               jjtree.clearNodeScope(jjtn002);
               jjtc002 = false;
             } else {
               jjtree.popNode();
             }
             if (jjte002 instanceof RuntimeException) {
               {if (true) throw (RuntimeException)jjte002;}
             }
             if (jjte002 instanceof ParseException) {
               {if (true) throw (ParseException)jjte002;}
             }
             {if (true) throw (Error)jjte002;}
        } finally {
             if (jjtc002) {
               jjtree.closeNodeScope(jjtn002, true);
             }
        }
        break;
      default:
        jj_la1[22] = jj_gen;
        vide();
      }
    } finally {
      trace_return("exp2P");
    }
  }

  static final public void terme() throws ParseException {
    trace_call("terme");
    try {
      fact();
      terme2();
    } finally {
      trace_return("terme");
    }
  }

  static final public void terme2() throws ParseException {
    trace_call("terme2");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
        jj_consume_token(STAR);
        fact();
                ASTmult jjtn001 = new ASTmult(JJTMULT);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
        try {
          terme2();
        } catch (Throwable jjte001) {
                if (jjtc001) {
                  jjtree.clearNodeScope(jjtn001);
                  jjtc001 = false;
                } else {
                  jjtree.popNode();
                }
                if (jjte001 instanceof RuntimeException) {
                  {if (true) throw (RuntimeException)jjte001;}
                }
                if (jjte001 instanceof ParseException) {
                  {if (true) throw (ParseException)jjte001;}
                }
                {if (true) throw (Error)jjte001;}
        } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001, true);
                }
        }
        break;
      case SLASH:
        jj_consume_token(SLASH);
        fact();
                   ASTdiv jjtn002 = new ASTdiv(JJTDIV);
                   boolean jjtc002 = true;
                   jjtree.openNodeScope(jjtn002);
        try {
          terme2();
        } catch (Throwable jjte002) {
                   if (jjtc002) {
                     jjtree.clearNodeScope(jjtn002);
                     jjtc002 = false;
                   } else {
                     jjtree.popNode();
                   }
                   if (jjte002 instanceof RuntimeException) {
                     {if (true) throw (RuntimeException)jjte002;}
                   }
                   if (jjte002 instanceof ParseException) {
                     {if (true) throw (ParseException)jjte002;}
                   }
                   {if (true) throw (Error)jjte002;}
        } finally {
                   if (jjtc002) {
                     jjtree.closeNodeScope(jjtn002, true);
                   }
        }
        break;
      default:
        jj_la1[23] = jj_gen;
        vide();
      }
    } finally {
      trace_return("terme2");
    }
  }

  static final public void fact() throws ParseException {
    trace_call("fact");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IDENTIFIER:
        ident();
        fact2();
        break;
      case TRUE:
      ASTVrai jjtn001 = new ASTVrai(JJTVRAI);
      boolean jjtc001 = true;
      jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(TRUE);
        } finally {
      if (jjtc001) {
        jjtree.closeNodeScope(jjtn001, true);
      }
        }
        break;
      case FALSE:
      ASTFaux jjtn002 = new ASTFaux(JJTFAUX);
      boolean jjtc002 = true;
      jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(FALSE);
        } finally {
      if (jjtc002) {
        jjtree.closeNodeScope(jjtn002, true);
      }
        }
        break;
      case INTEGER_LITERAL:
      case NUMBER:
        nbre();
        break;
      case LPAREN:
        jj_consume_token(LPAREN);
        exp();
        jj_consume_token(RPAREN);
        break;
      default:
        jj_la1[24] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
      trace_return("fact");
    }
  }

  static final public void fact2() throws ParseException {
    trace_call("fact2");
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LPAREN:
          ASTappelE jjtn001 = new ASTappelE(JJTAPPELE);
          boolean jjtc001 = true;
          jjtree.openNodeScope(jjtn001);
        try {
          jj_consume_token(LPAREN);
          listexp();
          jj_consume_token(RPAREN);
        } catch (Throwable jjte001) {
          if (jjtc001) {
            jjtree.clearNodeScope(jjtn001);
            jjtc001 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte001 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte001;}
          }
          if (jjte001 instanceof ParseException) {
            {if (true) throw (ParseException)jjte001;}
          }
          {if (true) throw (Error)jjte001;}
        } finally {
          if (jjtc001) {
            jjtree.closeNodeScope(jjtn001, true);
          }
        }
        break;
      default:
        jj_la1[25] = jj_gen;
        ident2();
      }
    } finally {
      trace_return("fact2");
    }
  }

  static final public void vide() throws ParseException {
    trace_call("vide");
    try {

    } finally {
      trace_return("vide");
    }
  }

  static private boolean jj_initialized_once = false;
  static public MiniJajaTokenManager token_source;
  static SimpleCharStream jj_input_stream;
  static public Token token, jj_nt;
  static private int jj_ntk;
  static private int jj_gen;
  static final private int[] jj_la1 = new int[26];
  static private int[] jj_la1_0;
  static private int[] jj_la1_1;
  static {
      jj_la1_0();
      jj_la1_1();
   }
   private static void jj_la1_0() {
      jj_la1_0 = new int[] {0x80000,0x8000000,0x24080,0x4080,0x25080,0x25080,0x8800000,0x25080,0x25080,0x0,0x4080,0x40000000,0x8004a000,0x8004a000,0x400,0x8800000,0x0,0x80890800,0x40000000,0x80890800,0x0,0x0,0x0,0x0,0x80890800,0x800000,};
   }
   private static void jj_la1_1() {
      jj_la1_1 = new int[] {0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x4048,0x4048,0x91,0x0,0x91,0x3000,0x8c00,0xa0,0x300,0x1,0x0,};
   }

  public MiniJaja(java.io.InputStream stream) {
     this(stream, null);
  }
  public MiniJaja(java.io.InputStream stream, String encoding) {
    if (jj_initialized_once) {
      System.out.println("ERROR: Second call to constructor of static parser.  You must");
      System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
      System.out.println("       during parser generation.");
      throw new Error();
    }
    jj_initialized_once = true;
    try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source = new MiniJajaTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 26; i++) jj_la1[i] = -1;
  }

  static public void ReInit(java.io.InputStream stream) {
     ReInit(stream, null);
  }
  static public void ReInit(java.io.InputStream stream, String encoding) {
    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 26; i++) jj_la1[i] = -1;
  }

  public MiniJaja(java.io.Reader stream) {
    if (jj_initialized_once) {
      System.out.println("ERROR: Second call to constructor of static parser.  You must");
      System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
      System.out.println("       during parser generation.");
      throw new Error();
    }
    jj_initialized_once = true;
    jj_input_stream = new SimpleCharStream(stream, 1, 1);
    token_source = new MiniJajaTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 26; i++) jj_la1[i] = -1;
  }

  static public void ReInit(java.io.Reader stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 26; i++) jj_la1[i] = -1;
  }

  public MiniJaja(MiniJajaTokenManager tm) {
    if (jj_initialized_once) {
      System.out.println("ERROR: Second call to constructor of static parser.  You must");
      System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
      System.out.println("       during parser generation.");
      throw new Error();
    }
    jj_initialized_once = true;
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 26; i++) jj_la1[i] = -1;
  }

  public void ReInit(MiniJajaTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 26; i++) jj_la1[i] = -1;
  }

  static final private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      trace_token(token, "");
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  static final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
      trace_token(token, " (in getNextToken)");
    return token;
  }

  static final public Token getToken(int index) {
    Token t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  static final private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  static private java.util.Vector jj_expentries = new java.util.Vector();
  static private int[] jj_expentry;
  static private int jj_kind = -1;

  static public ParseException generateParseException() {
    jj_expentries.removeAllElements();
    boolean[] la1tokens = new boolean[48];
    for (int i = 0; i < 48; i++) {
      la1tokens[i] = false;
    }
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 26; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 48; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.addElement(jj_expentry);
      }
    }
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = (int[])jj_expentries.elementAt(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  static private int trace_indent = 0;
  static private boolean trace_enabled = true;

  static final public void enable_tracing() {
    trace_enabled = true;
  }

  static final public void disable_tracing() {
    trace_enabled = false;
  }

  static final private void trace_call(String s) {
    if (trace_enabled) {
      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
      System.out.println("Call:   " + s);
    }
    trace_indent = trace_indent + 2;
  }

  static final private void trace_return(String s) {
    trace_indent = trace_indent - 2;
    if (trace_enabled) {
      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
      System.out.println("Return: " + s);
    }
  }

  static final private void trace_token(Token t, String where) {
    if (trace_enabled) {
      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
      System.out.print("Consumed token: <" + tokenImage[t.kind]);
      if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
        System.out.print(": \"" + t.image + "\"");
      }
      System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
    }
  }

  static final private void trace_scan(Token t1, int t2) {
    if (trace_enabled) {
      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
      System.out.print("Visited token: <" + tokenImage[t1.kind]);
      if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
        System.out.print(": \"" + t1.image + "\"");
      }
      System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
    }
  }

        }
