final public SimpleNode Statement() throws ParseException {
  SimpleNode ifStat = null;
  SimpleNode elseStat = null;
  binaryExpression_AST expr = null;
  SimpleNode body = null;
  List<Unit> variables = null;
    if (jj_2_8(3)) {
                ifThenElseStat_AST jjtn001 = new ifThenElseStat_AST(JJTIFTHENELSESTAT_AST);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
      try {
        jj_consume_token(IF);
        jj_consume_token(LP);
        expr = Expression();
        jj_consume_token(RP);
        ifStat = Statement();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ELSE:
          jj_consume_token(ELSE);
          elseStat = Statement();
          break;
        default:
          jj_la1[19] = jj_gen;
          ;
        }
                                                                                                                       jjtree.closeNodeScope(jjtn001, true);
                                                                                                                       jjtc001 = false;
    jjtn001.ifStat = ifStat;
    jjtn001.elseStat = elseStat;
    jjtn001.condition = expr;
    {if (true) return jjtn001;}
      } 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);
                }
      }
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHILE:
     whileStat_AST jjtn002 = new whileStat_AST(JJTWHILESTAT_AST);
     boolean jjtc002 = true;
     jjtree.openNodeScope(jjtn002);
        try {
          jj_consume_token(WHILE);
          jj_consume_token(LP);
          expr = Expression();
          jj_consume_token(RP);
          body = Statement();
                                                               jjtree.closeNodeScope(jjtn002, true);
                                                               jjtc002 = false;
     jjtn002.condition = expr;
     jjtn002.body = body;
     {if (true) return jjtn002;}
        } 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 RETURN:
     returnStat_AST jjtn003 = new returnStat_AST(JJTRETURNSTAT_AST);
     boolean jjtc003 = true;
     jjtree.openNodeScope(jjtn003);
        try {
          jj_consume_token(RETURN);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case NEW:
          case SUPER:
          case THIS:
          case INTEGER:
          case TRUE:
          case FALSE:
          case CHARLITERAL:
          case STRINGLITERAL:
          case NULL:
          case LP:
          case NOT:
          case PLUS:
          case MINUS:
          case ID:
            expr = Expression();
            break;
          default:
            jj_la1[20] = jj_gen;
            ;
          }
          jj_consume_token(SCOLON);
                                               jjtree.closeNodeScope(jjtn003, true);
                                               jjtc003 = false;
    jjtn003.expr = expr;
    {if (true) return jjtn003;}
        } 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;
        if (jj_2_9(3)) {
                 expressionStat_AST jjtn004 = new expressionStat_AST(JJTEXPRESSIONSTAT_AST);
                 boolean jjtc004 = true;
                 jjtree.openNodeScope(jjtn004);
          try {
            body = StatementExpression();
            jj_consume_token(SCOLON);
                                                         jjtree.closeNodeScope(jjtn004, true);
                                                         jjtc004 = false;
    jjtn004.expressionStat = body;
    {if (true) return jjtn004;}
          } catch (Throwable jjte004) {
                 if (jjtc004) {
                   jjtree.clearNodeScope(jjtn004);
                   jjtc004 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte004 instanceof RuntimeException) {
                   {if (true) throw (RuntimeException)jjte004;}
                 }
                 if (jjte004 instanceof ParseException) {
                   {if (true) throw (ParseException)jjte004;}
                 }
                 {if (true) throw (Error)jjte004;}
          } finally {
                 if (jjtc004) {
                   jjtree.closeNodeScope(jjtn004, true);
                 }
          }
        } else if (jj_2_10(3)) {
                 varDeclStat_AST jjtn005 = new varDeclStat_AST(JJTVARDECLSTAT_AST);
                 boolean jjtc005 = true;
                 jjtree.openNodeScope(jjtn005);
          try {
            variables = FieldDeclarations(new FieldDetails());
                                                                     jjtree.closeNodeScope(jjtn005, true);
                                                                     jjtc005 = false;
    if (MODE == 0)
    {
        SYMBOL_TABLE.addVariablesToMethod(variables);
    }
    jjtn005.variables = variables;
    {if (true) return jjtn005;}
          } catch (Throwable jjte005) {
                 if (jjtc005) {
                   jjtree.clearNodeScope(jjtn005);
                   jjtc005 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte005 instanceof RuntimeException) {
                   {if (true) throw (RuntimeException)jjte005;}
                 }
                 if (jjte005 instanceof ParseException) {
                   {if (true) throw (ParseException)jjte005;}
                 }
                 {if (true) throw (Error)jjte005;}
          } finally {
                 if (jjtc005) {
                   jjtree.closeNodeScope(jjtn005, true);
                 }
          }
        } else if (jj_2_11(3)) {
                 block_AST jjtn006 = new block_AST(JJTBLOCK_AST);
                 boolean jjtc006 = true;
                 jjtree.openNodeScope(jjtn006);
          try {
            Block();
                          jjtree.closeNodeScope(jjtn006, true);
                          jjtc006 = false;
                         {if (true) return jjtn006;}
          } catch (Throwable jjte006) {
                 if (jjtc006) {
                   jjtree.clearNodeScope(jjtn006);
                   jjtc006 = false;
                 } else {
                   jjtree.popNode();
                 }
                 if (jjte006 instanceof RuntimeException) {
                   {if (true) throw (RuntimeException)jjte006;}
                 }
                 if (jjte006 instanceof ParseException) {
                   {if (true) throw (ParseException)jjte006;}
                 }
                 {if (true) throw (Error)jjte006;}
          } finally {
                 if (jjtc006) {
                   jjtree.closeNodeScope(jjtn006, true);
                 }
          }
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case BREAK:
     breakStat_AST jjtn007 = new breakStat_AST(JJTBREAKSTAT_AST);
     boolean jjtc007 = true;
     jjtree.openNodeScope(jjtn007);
            try {
              jj_consume_token(BREAK);
              jj_consume_token(SCOLON);
                       jjtree.closeNodeScope(jjtn007, true);
                       jjtc007 = false;
                      {if (true) return jjtn007;}
            } finally {
     if (jjtc007) {
       jjtree.closeNodeScope(jjtn007, true);
     }
            }
            break;
          case CONTINUE:
     continueStat_AST jjtn008 = new continueStat_AST(JJTCONTINUESTAT_AST);
     boolean jjtc008 = true;
     jjtree.openNodeScope(jjtn008);
            try {
              jj_consume_token(CONTINUE);
              jj_consume_token(SCOLON);
                          jjtree.closeNodeScope(jjtn008, true);
                          jjtc008 = false;
                         {if (true) return jjtn008;}
            } finally {
     if (jjtc008) {
       jjtree.closeNodeScope(jjtn008, true);
     }
            }
            break;
          case SCOLON:
     emptyStat_AST jjtn009 = new emptyStat_AST(JJTEMPTYSTAT_AST);
     boolean jjtc009 = true;
     jjtree.openNodeScope(jjtn009);
            try {
              jj_consume_token(SCOLON);
               jjtree.closeNodeScope(jjtn009, true);
               jjtc009 = false;
              {if (true) return jjtn009;}
            } finally {
     if (jjtc009) {
       jjtree.closeNodeScope(jjtn009, true);
     }
            }
            break;
          default:
            jj_la1[22] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
    }
    throw new Error("Missing return statement in function");
  }