/* Generated By:JavaCC: Do not edit this line. JavaCCParser.java */
package beauty.parsers.javacc;

import java.io.*;
import java.util.*;

public class JavaCCParser implements JavaCCParserConstants {
    Token t;
    String lineSep = System.getProperty("line.separator");

    boolean IN_CU = false;

    public String getText() {
        return token_source.getText();
    }

    public void resetTokenSource() {
        token_source.reset();
    }

    private void add(Token t) {
        token_source.add(t);
    }

    private void add(String s) {
        token_source.add(s);
    }

    private void trim() {
        token_source.trim();
    }

    private void trimNL() {
        token_source.trimNL();
    }

    void Block() {
        try {
            Block(false);
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }

    private void trimWhitespace() {
        token_source.trimWhitespace();
    }

    private void write() {
        token_source.write();
    }

    private void writeln() {
        token_source.writeln();
    }

    public void setLineSeparator(String le) {
        lineSep = le;
        token_source.setLineSeparator(le);
    }

  /*

   * Returns true if the next token is not in the FOLLOW list of "expansion".

   * It is used to decide when the end of an "expansion" has been reached.

   */
  boolean notTailOfExpansionUnit() {
    Token t = getToken(1);
    if (t.kind == BIT_OR || t.kind == COMMA || t.kind == RPAREN || t.kind == RBRACE || t.kind == RBRACKET) return false;
    return true;
  }

  public JavaCCParser(String fileName)
   {
      this(System.in);
      try { ReInit(new FileInputStream(new File(fileName))); }
      catch(Exception e) { e.printStackTrace(); }
   }

  public static void main(String args[]) {
    JavaCCParser parser;
    if (args.length == 0) {
      System.out.println("Java Parser Version 1.1:  Reading from standard input . . .");
      parser = new JavaCCParser(System.in);
    } else if (args.length == 1) {
      System.out.println("Java Parser Version 1.1:  Reading from file " + args[0] + " . . .");
      try {
        parser = new JavaCCParser(new java.io.FileInputStream(args[0]));
      } catch (java.io.FileNotFoundException e) {
        System.out.println("Java Parser Version 1.1:  File " + args[0] + " not found.");
        return;
      }
    } else {
      System.out.println("Java Parser Version 1.1:  Usage is one of:");
      System.out.println("         java JavaCCParser < inputfile");
      System.out.println("OR");
      System.out.println("         java JavaCCParser inputfile");
      return;
    }
    try {
      parser.CompilationUnit();
      System.out.println("Java Parser Version 1.1:  Java program parsed successfully.");
    } catch (ParseException e) {
      System.out.println(e.getMessage());
      System.out.println("Java Parser Version 1.1:  Encountered errors during parse.");
    }
  }

/************************************************

 * THE JAVACC GRAMMAR SPECIFICATION STARTS HERE *

 ************************************************/
  final public void javacc_input() throws ParseException {
    javacc_options();
    if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("PARSER_BEGIN")) {

    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
    t = jj_consume_token(IDENTIFIER);
    jj_consume_token(LPAREN);
                       write(); add(t); add(" (");
    identifier();
    jj_consume_token(RPAREN);
                                                                        add(")"); write();
    CompilationUnit();
    if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("PARSER_END")) {

    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
    t = jj_consume_token(IDENTIFIER);
    jj_consume_token(LPAREN);
                       write(); add(t); add(" (");
    identifier();
    jj_consume_token(RPAREN);
                                                                        add(")"); write();
    label_1:
    while (true) {
      production();
      if (jj_2_1(1)) {
        ;
      } else {
        break label_1;
      }
    }
    jj_consume_token(0);
  }

  final public void javacc_options() throws ParseException {
    if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("options")) {
      t = jj_consume_token(IDENTIFIER);
      jj_consume_token(LBRACE);
                           add(t); add(" {"); write(); ++token_source.level;
      label_2:
      while (true) {
        option_binding();
        if (jj_2_2(1)) {
          ;
        } else {
          break label_2;
        }
      }
      jj_consume_token(RBRACE);
                                                                                                          write(); --token_source.level; add("}"); write();
    } else {
      ;
    }
  }

  final public void option_binding() throws ParseException {
    if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("LOOKAHEAD")) {
      identifier();
    } else if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("IGNORE_CASE")) {
      identifier();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IDENTIFIER:
        identifier();
        break;
      case STATIC:
        jj_consume_token(STATIC);
             add("static");
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
    jj_consume_token(ASSIGN);
        add(" = ");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER_LITERAL:
      IntegerLiteral();
      break;
    case FALSE:
    case TRUE:
      BooleanLiteral();
      break;
    case STRING_LITERAL:
      StringLiteral();
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
    jj_consume_token(SEMICOLON);
        add(";"); write();
  }

  final public void production() throws ParseException {
    if (jj_2_3(1)) {
      javacode_production();
    } else if (jj_2_4(1)) {
      regular_expr_production();
    } else if (jj_2_5(1)) {
      token_manager_decls();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case BYTE:
      case CHAR:
      case DOUBLE:
      case FLOAT:
      case INT:
      case LONG:
      case SHORT:
      case VOID:
      case IDENTIFIER:
        bnf_production();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  final public void javacode_production() throws ParseException {
    if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("JAVACODE")) {

    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
    identifier();
    ResultType();
    identifier();
    FormalParameters();
    if (jj_2_6(2)) {
      jj_consume_token(THROWS);
      Name();
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          break label_3;
        }
        jj_consume_token(COMMA);
        Name();
      }
    } else {
      ;
    }
    if (jj_2_7(2)) {
      node_descriptor();
    } else {
      ;
    }
    Block();
  }

  final public void bnf_production() throws ParseException {
    ResultType();
    identifier();
    FormalParameters();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case THROWS:
      jj_consume_token(THROWS);
      Name();
      label_4:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          break label_4;
        }
        jj_consume_token(COMMA);
        Name();
      }
      break;
    default:
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 120:
      node_descriptor();
      break;
    default:
      ;
    }
    jj_consume_token(COLON);
        add(" :"); write();
    Block(true);
    jj_consume_token(LBRACE);
        write(); add("{"); write(); ++token_source.level;
    expansion_choices();
    jj_consume_token(RBRACE);
         writeln(); --token_source.level; add("}"); write();
  }

  final public void regular_expr_production() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LT:
      if (jj_2_8(2)) {
        jj_consume_token(LT);
        jj_consume_token(STAR);
        jj_consume_token(GT);
                               add("<*>"); write();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LT:
          jj_consume_token(LT);
          t = jj_consume_token(IDENTIFIER);
                         add("<"); add(t);
          label_5:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              break label_5;
            }
            jj_consume_token(COMMA);
            t = jj_consume_token(IDENTIFIER);
                                                                    add(", "); add(t);
          }
          jj_consume_token(GT);
                                                                                                  add(">"); write();
          break;
        default:
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      break;
    default:
      ;
    }
    regexpr_kind();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACKET:
      jj_consume_token(LBRACKET);
                         add("[");
      if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("IGNORE_CASE")) {

      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      identifier();
      jj_consume_token(RBRACKET);
                              add("]");
      break;
    default:
      ;
    }
    jj_consume_token(COLON);
                                add(" : "); write();
    jj_consume_token(LBRACE);
        add("{"); write(); ++token_source.level;
    regexpr_spec();
    label_6:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BIT_OR:
        ;
        break;
      default:
        break label_6;
      }
      jj_consume_token(BIT_OR);
           writeln(); add("| ");
      regexpr_spec();
    }
    jj_consume_token(RBRACE);
         writeln(); --token_source.level; add(token_source.ls + "}"); write();
  }

  final public void token_manager_decls() throws ParseException {
    if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("TOKEN_MGR_DECLS")) {

    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
    t = jj_consume_token(IDENTIFIER);
    jj_consume_token(COLON);
                       add(t); add(" : ");
    TokenMgrDeclBlock();
  }

  final public void regexpr_kind() throws ParseException {
    if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("TOKEN")) {
      identifier();
    } else if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("SPECIAL_TOKEN")) {
      identifier();
    } else if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("SKIP")) {
      identifier();
    } else if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("MORE")) {
      identifier();
    } else {
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void regexpr_spec() throws ParseException {
    regular_expression();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
      Block();
      break;
    default:
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case COLON:
      jj_consume_token(COLON);
      t = jj_consume_token(IDENTIFIER);
                                                            add(" : "); add(t);
      break;
    default:
      ;
    }
  }

  final public void expansion_choices() throws ParseException {
    expansion();
    label_7:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BIT_OR:
        ;
        break;
      default:
        break label_7;
      }
      jj_consume_token(BIT_OR);
                        writeln(); add("| ");
      expansion();
                                                              write();
    }
  }

  final public void expansion() throws ParseException {
    if (jj_2_9(1)) {
      if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("LOOKAHEAD")) {

      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      t = jj_consume_token(IDENTIFIER);
      jj_consume_token(LPAREN);
                         add(t); add(" ( ");
      local_lookahead();
      jj_consume_token(RPAREN);
                                                                       add(" ) "); writeln();
    } else {
      ;
    }
    label_8:
    while (true) {
      expansion_unit();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 120:
        node_descriptor();
        break;
      default:
        ;
      }
      if (notTailOfExpansionUnit()) {
        ;
      } else {
        break label_8;
      }
    }
  }

  final public void local_lookahead() throws ParseException {
          boolean commaAtEnd = false, emptyLA = true;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case INTEGER_LITERAL:
      IntegerLiteral();
          emptyLA = false;
      break;
    default:
      ;
    }
    if (!emptyLA && (getToken(1).kind != RPAREN)) {
      jj_consume_token(COMMA);
          add(", ");
          commaAtEnd = true;
    } else {
      ;
    }
    if (getToken(1).kind != RPAREN && getToken(1).kind != LBRACE) {
      expansion_choices();
          emptyLA = false; commaAtEnd = false;
    } else {
      ;
    }
    if (!emptyLA && !commaAtEnd && (getToken(1).kind != RPAREN)) {
      jj_consume_token(COMMA);
          add(", ");
          commaAtEnd = true;
    } else {
      ;
    }
    if (emptyLA || commaAtEnd) {
      jj_consume_token(LBRACE);
        add("{ ");
      Expression();
      jj_consume_token(RBRACE);
                                        add(" }");
    } else {
      ;
    }
  }

  final public void expansion_unit() throws ParseException {
    if (jj_2_11(1)) {
      if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("LOOKAHEAD")) {

      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      t = jj_consume_token(IDENTIFIER);
      jj_consume_token(LPAREN);
                       add(t); add(" ( ");
      local_lookahead();
      jj_consume_token(RPAREN);
                                                                     add(" ) "); writeln();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        Block();
        break;
      case LBRACKET:
        jj_consume_token(LBRACKET);
        writeln(); add(" [ "); writeln(); ++token_source.level;
        expansion_choices();
        jj_consume_token(RBRACKET);
                                                                                            writeln(); --token_source.level; add(" ] "); writeln();
        break;
      case TRY:
        jj_consume_token(TRY);
        jj_consume_token(LBRACE);
              add("try {"); write();
        expansion_choices();
        jj_consume_token(RBRACE);
                                                                 write(); add("}");
        label_9:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case CATCH:
            ;
            break;
          default:
            break label_9;
          }
          jj_consume_token(CATCH);
          jj_consume_token(LPAREN);
                  add("catch ( ");
          Name();
          t = jj_consume_token(IDENTIFIER);
          jj_consume_token(RPAREN);
                                                                 add(t); add(" ) ");
          Block();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case FINALLY:
          jj_consume_token(FINALLY);
                add("finally ");
          Block();
          break;
        default:
          ;
        }
        break;
      default:
        if (jj_2_12(2147483647)) {
          if (jj_2_10(2147483647)) {
            PrimaryExpression();
            jj_consume_token(ASSIGN);
                              add(" = ");
          } else {
            ;
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case STRING_LITERAL:
          case LT:
            regular_expression();
            break;
          case IDENTIFIER:
            identifier();
            Arguments();
            break;
          default:
            jj_consume_token(-1);
            throw new ParseException();
          }
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LPAREN:
            jj_consume_token(LPAREN);
        writeln(); add(" ( "); writeln(); ++token_source.level;
            expansion_choices();
            jj_consume_token(RPAREN);
                                                                                            writeln(); --token_source.level; add(" )"); writeln();
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case HOOK:
            case PLUS:
            case STAR:
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case PLUS:
                jj_consume_token(PLUS);
                                                                                                                                                             trimWhitespace(); add("+"); writeln();
                break;
              case STAR:
                jj_consume_token(STAR);
                                                                                                                                                                                                              trimWhitespace(); add("*"); writeln();
                break;
              case HOOK:
                jj_consume_token(HOOK);
                                                                                                                                                                                                                                                               trimWhitespace(); add("?"); writeln();
                break;
              default:
                jj_consume_token(-1);
                throw new ParseException();
              }
              break;
            default:
              ;
            }
            break;
          default:
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
    }
  }

  final public void regular_expression() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STRING_LITERAL:
      StringLiteral();
      break;
    default:
      if (jj_2_13(3)) {
        jj_consume_token(LT);
        add("<");
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IDENTIFIER:
        case 120:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case 120:
            jj_consume_token(120);
                              add("#");
            break;
          default:
            ;
          }
          identifier();
          jj_consume_token(COLON);
                                                               add(": ");
          break;
        default:
          ;
        }
        complex_regular_expression_choices();
        jj_consume_token(GT);
                                                                                                                         add(">");
      } else if (jj_2_14(2)) {
        jj_consume_token(LT);
        add("<");
        identifier();
        jj_consume_token(GT);
                                       add(">");
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LT:
          jj_consume_token(LT);
        add("<");
          if (getToken(1).kind == IDENTIFIER && getToken(1).image.equals("EOF")) {

          } else {
            jj_consume_token(-1);
            throw new ParseException();
          }
          identifier();
          jj_consume_token(GT);
        add(">");
          break;
        default:
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    }
  }

  final public void complex_regular_expression_choices() throws ParseException {
    complex_regular_expression();
    label_10:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BIT_OR:
        ;
        break;
      default:
        break label_10;
      }
      jj_consume_token(BIT_OR);
                                         add(token_source.ls + " | ");
      complex_regular_expression();
                                                                                                       write();
    }
  }

  final public void complex_regular_expression() throws ParseException {
    label_11:
    while (true) {
      complex_regular_expression_unit();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STRING_LITERAL:
      case LPAREN:
      case LBRACKET:
      case LT:
      case TILDE:
        ;
        break;
      default:
        break label_11;
      }
    }
  }

  final public void complex_regular_expression_unit() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STRING_LITERAL:
      StringLiteral();
      break;
    case LT:
      jj_consume_token(LT);
        add("<");
      identifier();
      jj_consume_token(GT);
                                       add(">");
      break;
    case LBRACKET:
    case TILDE:
      character_list();
      break;
    case LPAREN:
      jj_consume_token(LPAREN);
        add("( ");
      complex_regular_expression_choices();
      jj_consume_token(RPAREN);
                                                                add(" )");
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case HOOK:
      case PLUS:
      case STAR:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case PLUS:
          jj_consume_token(PLUS);
                                                                                     add("+");
          break;
        case STAR:
          jj_consume_token(STAR);
                                                                                                         add("*");
          break;
        case HOOK:
          jj_consume_token(HOOK);
                                                                                                                             add("?");
          break;
        default:
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        ;
      }
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void character_list() throws ParseException {
    writeln();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case TILDE:
      jj_consume_token(TILDE);
          add("~");
      break;
    default:
      ;
    }
    jj_consume_token(LBRACKET);
                              add("[");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STRING_LITERAL:
      character_descriptor();
      label_12:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          break label_12;
        }
        jj_consume_token(COMMA);
                                                                           add(",");
        character_descriptor();
      }
      break;
    default:
      ;
    }
    jj_consume_token(RBRACKET);
                                                                                                                         add("]");
  }

  final public void character_descriptor() throws ParseException {
    StringLiteral();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case MINUS:
      jj_consume_token(MINUS);
                          add("-");
      StringLiteral();
      break;
    default:
      ;
    }
  }

  final public void identifier() throws ParseException {
    t = jj_consume_token(IDENTIFIER);
      add(t);
  }

/**********************************************

 * THE JJTREE PRODUCTIONS START HERE          *

 **********************************************/
  final public void node_descriptor() throws ParseException {
    jj_consume_token(120);
        add("#");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IDENTIFIER:
      identifier();
      break;
    case VOID:
      t = jj_consume_token(VOID);
                                                add(t);
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LPAREN:
      jj_consume_token(LPAREN);
         add("(");
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case GT:
        jj_consume_token(GT);
                             add(">");
        break;
      default:
        ;
      }
      node_descriptor_expression();
      jj_consume_token(RPAREN);
                                                                              add(")");
      break;
    default:
      ;
    }
  }

  void node_descriptor_expression() throws ParseException {
  Token tok;
  int nesting = 1;
  while (true) {
    tok = getToken(1);
    if (tok.kind == 0) {
      throw new ParseException();
    }
    if (tok.kind == LPAREN) nesting++;
    if (tok.kind == RPAREN) {
      nesting--;
      if (nesting == 0) break;
    }
    tok = getNextToken();
  }
  }

/*****************************************

 * THE JAVA LANGUAGE GRAMMAR STARTS HERE *

 *****************************************/

/*

 * Program structuring syntax follows.

 */
  final public void CompilationUnit() throws ParseException {
    IN_CU = true;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case PACKAGE:
      PackageDeclaration();
      break;
    default:
      ;
    }
    label_13:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IMPORT:
        ;
        break;
      default:
        break label_13;
      }
      ImportDeclaration();
    }
    label_14:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ABSTRACT:
      case CLASS:
      case ENUM:
      case FINAL:
      case INTERFACE:
      case NATIVE:
      case PRIVATE:
      case PROTECTED:
      case PUBLIC:
      case STATIC:
      case STRICTFP:
      case SYNCHRONIZED:
      case TRANSIENT:
      case VOLATILE:
      case SEMICOLON:
      case AT:
        ;
        break;
      default:
        break label_14;
      }
      TypeDeclaration();
    }
    IN_CU = false;
  }

  final public void PackageDeclaration() throws ParseException {
    t = jj_consume_token(PACKAGE);
                  add(t);
    Name();
    jj_consume_token(SEMICOLON);
                                         add(";"); write();
  }

  final public void ImportDeclaration() throws ParseException {
    jj_consume_token(IMPORT);
             add("import");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STATIC:
      jj_consume_token(STATIC);
                                           add("static");
      break;
    default:
      ;
    }
    Name();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case DOT:
      jj_consume_token(DOT);
      jj_consume_token(STAR);
                                                                                 add(".*");
      break;
    default:
      ;
    }
    jj_consume_token(SEMICOLON);
                                                                                                      add(";"); write();
  }

/*

 * Modifiers. We match all modifiers in a single rule to reduce the chances of

 * syntax errors for simple modifier mistakes. It will also enable us to give

 * better error messages.

 */
  final public int Modifiers() throws ParseException {
   int modifiers = 0;
    label_15:
    while (true) {
      if (jj_2_15(2)) {
        ;
      } else {
        break label_15;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PUBLIC:
        jj_consume_token(PUBLIC);
              modifiers |= ModifierSet.PUBLIC;
        break;
      case STATIC:
        jj_consume_token(STATIC);
              modifiers |= ModifierSet.STATIC;
        break;
      case PROTECTED:
        jj_consume_token(PROTECTED);
                 modifiers |= ModifierSet.PROTECTED;
        break;
      case PRIVATE:
        jj_consume_token(PRIVATE);
               modifiers |= ModifierSet.PRIVATE;
        break;
      case FINAL:
        jj_consume_token(FINAL);
             modifiers |= ModifierSet.FINAL;
        break;
      case ABSTRACT:
        jj_consume_token(ABSTRACT);
                modifiers |= ModifierSet.ABSTRACT;
        break;
      case SYNCHRONIZED:
        jj_consume_token(SYNCHRONIZED);
                    modifiers |= ModifierSet.SYNCHRONIZED;
        break;
      case NATIVE:
        jj_consume_token(NATIVE);
              modifiers |= ModifierSet.NATIVE;
        break;
      case TRANSIENT:
        jj_consume_token(TRANSIENT);
                 modifiers |= ModifierSet.TRANSIENT;
        break;
      case VOLATILE:
        jj_consume_token(VOLATILE);
                modifiers |= ModifierSet.VOLATILE;
        break;
      case STRICTFP:
        jj_consume_token(STRICTFP);
                modifiers |= ModifierSet.STRICTFP;
        break;
      case AT:
        Annotation();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
    {if (true) return modifiers;}
    throw new Error("Missing return statement in function");
  }

/*

 * Declaration syntax follows.

 */
  final public void TypeDeclaration() throws ParseException {
   int modifiers;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SEMICOLON:
      jj_consume_token(SEMICOLON);
          add(";"); write();
      break;
    case ABSTRACT:
    case CLASS:
    case ENUM:
    case FINAL:
    case INTERFACE:
    case NATIVE:
    case PRIVATE:
    case PROTECTED:
    case PUBLIC:
    case STATIC:
    case STRICTFP:
    case SYNCHRONIZED:
    case TRANSIENT:
    case VOLATILE:
    case AT:
      modifiers = Modifiers();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLASS:
      case INTERFACE:
        ClassOrInterfaceDeclaration(modifiers);
        break;
      case ENUM:
        EnumDeclaration(modifiers);
        break;
      case AT:
        AnnotationTypeDeclaration(modifiers);
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
   boolean isInterface = false;
   add(ModifierSet.toString(modifiers) + " ");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case CLASS:
      jj_consume_token(CLASS);
              add("class");
      break;
    case INTERFACE:
      jj_consume_token(INTERFACE);
                                              add("interface");  isInterface = true;
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
    t = jj_consume_token(IDENTIFIER);
                   add(t);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LT:
      TypeParameters();
      break;
    default:
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case EXTENDS:
      ExtendsList(isInterface);
      break;
    default:
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IMPLEMENTS:
      ImplementsList(isInterface);
      break;
    default:
      ;
    }
    ClassOrInterfaceBody(isInterface);
  }

  final public void ExtendsList(boolean isInterface) throws ParseException {
   boolean extendsMoreThanOne = false;
    jj_consume_token(EXTENDS);
               add("extends");
    ClassOrInterfaceType();
    label_16:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_16;
      }
      jj_consume_token(COMMA);
           add(",");
      ClassOrInterfaceType();
                                                extendsMoreThanOne = true;
    }
      if (extendsMoreThanOne && !isInterface)
         {if (true) throw new ParseException("A class cannot extend more than one other class");}
  }

  final public void ImplementsList(boolean isInterface) throws ParseException {
    jj_consume_token(IMPLEMENTS);
                  add("implements");
    ClassOrInterfaceType();
    label_17:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_17;
      }
      jj_consume_token(COMMA);
           add(",");
      ClassOrInterfaceType();
    }
      if (isInterface)
         {if (true) throw new ParseException("An interface cannot implement other interfaces");}
  }

  final public void EnumDeclaration(int modifiers) throws ParseException {
    add(ModifierSet.toString(modifiers) + " ");
    jj_consume_token(ENUM);
           add("enum");
    t = jj_consume_token(IDENTIFIER);
                                           add(t);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IMPLEMENTS:
      ImplementsList(false);
      break;
    default:
      ;
    }
    EnumBody();
  }

  final public void EnumBody() throws ParseException {
    jj_consume_token(LBRACE);
          add("{");
    EnumConstant();
    label_18:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_18;
      }
      jj_consume_token(COMMA);
                          add(",");
      EnumConstant();
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case SEMICOLON:
      jj_consume_token(SEMICOLON);
           add(";"); write();
      label_19:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ABSTRACT:
        case BOOLEAN:
        case BYTE:
        case CHAR:
        case CLASS:
        case DOUBLE:
        case ENUM:
        case FINAL:
        case FLOAT:
        case INT:
        case INTERFACE:
        case LONG:
        case NATIVE:
        case PRIVATE:
        case PROTECTED:
        case PUBLIC:
        case SHORT:
        case STATIC:
        case STRICTFP:
        case SYNCHRONIZED:
        case TRANSIENT:
        case VOID:
        case VOLATILE:
        case IDENTIFIER:
        case LBRACE:
        case SEMICOLON:
        case AT:
        case LT:
          ;
          break;
        default:
          break label_19;
        }
        ClassOrInterfaceBodyDeclaration(false);
      }
      break;
    default:
      ;
    }
    jj_consume_token(RBRACE);
         add("}"); write();
  }

  final public void EnumConstant() throws ParseException {
    t = jj_consume_token(IDENTIFIER);
                   add(t);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LPAREN:
      Arguments();
      break;
    default:
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
      ClassOrInterfaceBody(false);
      break;
    default:
      ;
    }
  }

  final public void TypeParameters() throws ParseException {
    jj_consume_token(LT);
          add("<");
    TypeParameter();
    label_20:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_20;
      }
      jj_consume_token(COMMA);
                                              add(",");
      TypeParameter();
    }
    jj_consume_token(GT);
                                                                                   add("> ");
  }

  final public void TypeParameter() throws ParseException {
    t = jj_consume_token(IDENTIFIER);
                     add(t);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case EXTENDS:
      TypeBound();
      break;
    default:
      ;
    }
  }

  final public void TypeBound() throws ParseException {
    jj_consume_token(EXTENDS);
                add("extends");
    ClassOrInterfaceType();
    label_21:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BIT_AND:
        ;
        break;
      default:
        break label_21;
      }
      jj_consume_token(BIT_AND);
                                                                 add("&");
      ClassOrInterfaceType();
    }
  }

  final public void ClassOrInterfaceBody(boolean isInterface) throws ParseException {
    jj_consume_token(LBRACE);
          add("{"); write(); ++token_source.level;
    label_22:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ABSTRACT:
      case BOOLEAN:
      case BYTE:
      case CHAR:
      case CLASS:
      case DOUBLE:
      case ENUM:
      case FINAL:
      case FLOAT:
      case INT:
      case INTERFACE:
      case LONG:
      case NATIVE:
      case PRIVATE:
      case PROTECTED:
      case PUBLIC:
      case SHORT:
      case STATIC:
      case STRICTFP:
      case SYNCHRONIZED:
      case TRANSIENT:
      case VOID:
      case VOLATILE:
      case IDENTIFIER:
      case LBRACE:
      case SEMICOLON:
      case AT:
      case LT:
        ;
        break;
      default:
        break label_22;
      }
      ClassOrInterfaceBodyDeclaration(isInterface);
    }
    jj_consume_token(RBRACE);
                                                                                                             add("}"); --token_source.level; write();
  }

  final public void ClassOrInterfaceBodyDeclaration(boolean isInterface) throws ParseException {
   boolean isNestedInterface = false;
   int modifiers;
    if (jj_2_18(2)) {
      Initializer();
     if (isInterface)
        {if (true) throw new ParseException("An interface cannot have initializers");}
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ABSTRACT:
      case BOOLEAN:
      case BYTE:
      case CHAR:
      case CLASS:
      case DOUBLE:
      case ENUM:
      case FINAL:
      case FLOAT:
      case INT:
      case INTERFACE:
      case LONG:
      case NATIVE:
      case PRIVATE:
      case PROTECTED:
      case PUBLIC:
      case SHORT:
      case STATIC:
      case STRICTFP:
      case SYNCHRONIZED:
      case TRANSIENT:
      case VOID:
      case VOLATILE:
      case IDENTIFIER:
      case AT:
      case LT:
        modifiers = Modifiers();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CLASS:
        case INTERFACE:
          ClassOrInterfaceDeclaration(modifiers);
          break;
        case ENUM:
          EnumDeclaration(modifiers);
          break;
        default:
          if (jj_2_16(2147483647)) {
            ConstructorDeclaration(modifiers);
          } else if (jj_2_17(2147483647)) {
            FieldDeclaration(modifiers);
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
            case VOID:
            case IDENTIFIER:
            case LT:
              MethodDeclaration(modifiers);
              break;
            default:
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
        }
        break;
      case SEMICOLON:
        jj_consume_token(SEMICOLON);
        add(";"); write();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  final public void FieldDeclaration(int modifiers) throws ParseException {
    add(ModifierSet.toString(modifiers) + " ");
    Type();
    VariableDeclarator();
    label_23:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        break label_23;
      }
      jj_consume_token(COMMA);
                                      add(",");
      VariableDeclarator();
    }
    jj_consume_token(SEMICOLON);
                                                                                add(";"); write();
  }

  final public void VariableDeclarator() throws ParseException {
    VariableDeclaratorId();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ASSIGN:
      jj_consume_token(ASSIGN);
                                 add(" = ");
      VariableInitializer();
      break;
    default:
      ;
    }
  }

  final public void VariableDeclaratorId() throws ParseException {
    t = jj_consume_token(IDENTIFIER);
                   add(t);
    label_24:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
        ;
        break;
      default:
        break label_24;
      }
      jj_consume_token(LBRACKET);
      jj_consume_token(RBRACKET);
                                         add("[]");
    }
  }

  final public void VariableInitializer() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
      ArrayInitializer();
      break;
    case BOOLEAN:
    case BYTE:
    case CHAR:
    case DOUBLE:
    case FALSE:
    case FLOAT:
    case INT:
    case LONG:
    case NEW:
    case NULL:
    case SHORT:
    case SUPER:
    case THIS:
    case TRUE:
    case VOID:
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
    case CHARACTER_LITERAL:
    case STRING_LITERAL:
    case IDENTIFIER:
    case LPAREN:
    case BANG:
    case TILDE:
    case INCR:
    case DECR:
    case PLUS:
    case MINUS:
      Expression();
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ArrayInitializer() throws ParseException {
    jj_consume_token(LBRACE);
          add("{");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case BOOLEAN:
    case BYTE:
    case CHAR:
    case DOUBLE:
    case FALSE:
    case FLOAT:
    case INT:
    case LONG:
    case NEW:
    case NULL:
    case SHORT:
    case SUPER:
    case THIS:
    case TRUE:
    case VOID:
    case INTEGER_LITERAL:
    case FLOATING_POINT_LITERAL:
    case CHARACTER_LITERAL:
    case STRING_LITERAL:
    case IDENTIFIER:
    case LPAREN:
    case LBRACE:
    case BANG:
    case TILDE:
    case INCR:
    case DECR:
    case PLUS:
    case MINUS:
      VariableInitializer();
      label_25:
      while (true) {
        if (jj_2_19(2)) {
          ;
        } else {
          break label_25;
        }
        jj_consume_token(COMMA);
                                                                   add(",");
        VariableInitializer();
      }
      break;
    default:
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case COMMA:
      jj_consume_token(COMMA);
                                                                                                                  add(",");
      break;
    default:
      ;
    }
    jj_consume_token(RBRACE);
                                                                                                                                      add("}"); write();
  }

  final public void MethodDeclaration(int modifiers) throws ParseException {
    add(ModifierSet.toString(modifiers) + " ");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LT:
      TypeParameters();
      break;
    default:
      ;
    }
    ResultType();
    MethodDeclarator();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case THROWS:
      jj_consume_token(THROWS);
                                  add("throws");
      NameList();
      break;
    default:
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LBRACE:
      Block();
      break;
    case SEMICOLON:
      jj_consume_token(SEMICOLON);
                    add(";"); write();
      break;
    default:
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void MethodDeclarator() throws ParseException {
    t = jj_consume_token(IDENTIFIER);
                   add(t);
    FormalParameters();
    label_26:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
        ;
        break;
      default:
        break label_26;
      }
      jj_consume_token(LBRACKET);
      jj_consume_token(RBRACKET);
                                                            add("[]");
    }
  }

  final public void FormalParameters() throws ParseException {
    boolean added = false;
    jj_consume_token(LPAREN);
          add("(");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case BOOLEAN:
    case BYTE:
    case CHAR:
    case DOUBLE:
    case FINAL:
    case FLOAT:
    case INT:
    case LONG:
    case SHORT:
    case IDENTIFIER:
      FormalParameter();
                                            added = true;
      label_27:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          break label_27;
        }
        jj_consume_token(COMMA);
                                                                    add(",");
        FormalParameter();
      }
      break;
    default:
      ;
    }
    jj_consume_token(RPAREN);
                                                                                                             if (!added) trim(); add(")");
  }

  final public void FormalParameter() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case FINAL:
      jj_consume_token(FINAL);
              add("final");
      break;
    default:
      ;
    }
    Type();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ELLIPSIS:
      jj_consume_token(ELLIPSIS);
                                                 trim(); add("...");
      break;
    default:
      ;
    }
    VariableDeclaratorId();
  }

  final public void ConstructorDeclaration(int modifiers) throws ParseException {
    add(ModifierSet.toString(modifiers) + " ");
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LT:
      TypeParameters();
      break;
    default:
      ;
    }
    t = jj_consume_token(IDENTIFIER);
                   add(t);
    FormalParameters();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case THROWS:
      jj_consume_token(THROWS);
                                                             add("throws");
      NameList();
      break;
    default:
      ;
    }
    jj_consume_token(LBRACE);
        add("{"); write(); ++token_source.level;
    if (jj_2_20(2147483647)) {
      ExplicitConstructorInvocation();
    } else {
      ;
    }
    label_28:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ASSERT:
      case BOOLEAN:
      case BREAK:
      case BYTE:
      case CHAR:
      case CLASS:
      case CONTINUE:
      case DO:
      case DOUBLE:
      case FALSE:
      case FINAL:
      case FLOAT:
      case FOR:
      case IF:
      case INT:
      case INTERFACE:
      case LONG:
      case NEW:
      case NULL:
      case RETURN:
      case SHORT:
      case SUPER:
      case SWITCH:
      case SYNCHRONIZED:
      case THIS:
      case THROW:
      case TRUE:
      case TRY:
      case VOID:
      case WHILE:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case IDENTIFIER:
      case LPAREN:
      case LBRACE:
      case SEMICOLON:
      case INCR:
      case DECR:
        ;
        break;
      default:
        break label_28;
      }
      BlockStatement();
    }
    jj_consume_token(RBRACE);
        add("}"); --token_source.level; write();
  }

  final public void ExplicitConstructorInvocation() throws ParseException {
    if (jj_2_22(2147483647)) {
      jj_consume_token(THIS);
           add("this");
      Arguments();
      jj_consume_token(SEMICOLON);
                                            add(";"); write();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case BYTE:
      case CHAR:
      case DOUBLE:
      case FALSE:
      case FLOAT:
      case INT:
      case LONG:
      case NEW:
      case NULL:
      case SHORT:
      case SUPER:
      case THIS:
      case TRUE:
      case VOID:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case IDENTIFIER:
      case LPAREN:
        if (jj_2_21(2)) {
          PrimaryExpression();
          jj_consume_token(DOT);
        } else {
          ;
        }
        jj_consume_token(SUPER);
                                                     add("super");
        Arguments();
        jj_consume_token(SEMICOLON);
                                                                                       add(";"); write();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  final public void Initializer() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case STATIC:
      jj_consume_token(STATIC);
               add("static ");
      break;
    default:
      ;
    }
    Block();
  }

/*

 * Type, name and expression syntax follows.

 */
  final public void Type() throws ParseException {
    if (jj_2_23(2)) {
      ReferenceType();
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BOOLEAN:
      case BYTE:
      case CHAR:
      case DOUBLE:
      case FLOAT:
      case INT:
      case LONG:
      case SHORT:
        PrimitiveType();
        break;
      default:
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
  }

  final public void ReferenceType() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case BOOLEAN:
    case BYTE:
    case CHAR:
    case DOUBLE:
    case FLOAT:
    case INT:
    case LONG:
    case SHORT:
      PrimitiveType();
      label_29:
      while (true) {
        jj_consume_token(LBRACKET);
        jj_consume_token(RBRACKET);
                                            add("[]");…