gt:     if (jjtc000) {
context: /* Generated By:JJTree&JavaCC: Do not edit this line. AsnParser.java */
  //Title:       
  //Version:     $Id: AsnParser.java,v 1.3 2005/02/07 10:25:43 ibbo Exp $
  //Copyright:   
  //Author:      Ian Ibbotson
  //Company:     
  //Description: 
  //
  
  package org.jzkit.a2j.codec.comp;
  
  import java.util.*;
  import java.io.File;
  import java.io.FileInputStream;
  
  public class AsnParser/*@bgen(jjtree)*/implements AsnParserTreeConstants, AsnParserConstants {/*@bgen(jjtree)*/
    protected JJTAsnParserState jjtree = new JJTAsnParserState();// public static void main(String args[]) throws ParseException {
  
    //   System.err.println("Args :"+args);
  
    //   for ( int i=0; i<args.length; i++ )
    //   {
    //     System.err.println("Processing asn source file : "+args[i]);
  
    //     File next_asn_file = new File(args[i]);
  
    //     if ( next_asn_file.exists() )       
    //     {
          // parser = new AsnParser(System.in);
    //       try 
    //       {
    //         AsnParser parser = new AsnParser(new FileInputStream(next_asn_file));
    //         parser.Input();	
    //         System.out.println("ASN.1 file parsed successfully... Calling pass1");
    //         parser.jjtree.rootNode().pass1();
    //         System.out.println("Calling outputJava");
            // parser.jjtree.rootNode().outputJava();
    //         CodecBuilderInfo.getInfo().create();
    //         System.out.println("Done outputting java");
    //       }
    //       catch(ParseException e)
    //       {
    //         System.out.println(e.toString());
    //         e.printStackTrace();
    //       }
    //       catch(java.io.FileNotFoundException fnfe)
    //       {
    //         System.out.println(fnfe.toString());
    //         fnfe.printStackTrace();
    //       }
    //     }
    //   }
    // }
  
    private String output_dir = null;
    private String package_name = null;
  
    public String getPackageName()
    {
      return package_name;
    }
  
    public void setPackageName(String package_name)
    {
      this.package_name = package_name;
    }
  
    public String getOutputDir() {
      return output_dir;
    }
  
    public void setOutputDir(String output_dir) {
      this.output_dir = output_dir;
    }
  
  
    public static String usefulTypes[] = {
          "GraphicString",  "NumericString", "PrintableString",
          "TeletexString", "T61String", "VideotexString", "IA5String",
          "VisibleString", "ISO646String", "GeneralizedTime", "UniversalString", "BMPString", "EXTERNAL" };
  
    public static String builtinTypes[] = {
          "Integer", "BitString", "SetOrSequenceType", "SetOrSequenceOfType",
          "ChoiceType", "SelectionType", "TaggedType", "Any", "Enumerated",
          "OctetString", "OID", "REAL", "BOOL", "NULL" };
  
    final public void Input() throws ParseException {
                  /*@bgen(jjtree) Input */
    ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        label_1:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case UCASEFIRST_IDENT_TKN:
            ;
            break;
          default:
            jj_la1[0] = jj_gen;
            break label_1;
          }
          ModuleDefinition();
        }
      } 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);
     }
      }
    }
  
    final public void ModuleDefinition() throws ParseException {
                             /*@bgen(jjtree) ModuleDefinition */
                              ASTModuleDefinition jjtn000 = new ASTModuleDefinition(this, JJTMODULEDEFINITION);
                              boolean jjtc000 = true;
                              jjtree.openNodeScope(jjtn000);Token t;
      try {
        ModuleIdentifier();
        jj_consume_token(DEFINITIONS_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IMPLICIT_TKN:
        case EXPLICIT_TKN:
          TagDefault();
          break;
        default:
          jj_la1[1] = jj_gen;
          ;
        }
        jj_consume_token(GETS_TKN);
        jj_consume_token(BEGIN_TKN);
        ModuleBody();
        jj_consume_token(END_TKN);
      } 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);
      }
      }
    }
  
    final public void TagDefault() throws ParseException {
                       /*@bgen(jjtree) TagDefault */
    ASTTagDefault jjtn000 = new ASTTagDefault(this, JJTTAGDEFAULT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case EXPLICIT_TKN:
          jj_consume_token(EXPLICIT_TKN);
                       jjtn000.which = 1;
          break;
        case IMPLICIT_TKN:
          jj_consume_token(IMPLICIT_TKN);
                                                                jjtn000.which = 2;
          break;
        default:
          jj_la1[2] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jj_consume_token(TAGS_TKN);
      } finally {
       if (jjtc000) {
         jjtree.closeNodeScope(jjtn000, true);
       }
      }
    }
  
    final public void ModuleIdentifier() throws ParseException {
                             /*@bgen(jjtree) ModuleIdentifier */
    ASTModuleIdentifier jjtn000 = new ASTModuleIdentifier(this, JJTMODULEIDENTIFIER);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        modulereference();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LEFTBRACE_TKN:
          AssignedIdentifier();
          break;
        default:
          jj_la1[3] = jj_gen;
          ;
        }
      } 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);
       }
      }
    }
  
    final public void AssignedIdentifier() throws ParseException {
                               /*@bgen(jjtree) AssignedIdentifier */
    ASTAssignedIdentifier jjtn000 = new ASTAssignedIdentifier(this, JJTASSIGNEDIDENTIFIER);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        ObjectIdentifierValue();
      } 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);
       }
      }
    }
  
    final public void ModuleBody() throws ParseException {
                       /*@bgen(jjtree) ModuleBody */
    ASTModuleBody jjtn000 = new ASTModuleBody(this, JJTMODULEBODY);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case EXPORTS_TKN:
          Exports();
          break;
        default:
          jj_la1[4] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IMPORTS_TKN:
          Imports();
          break;
        default:
          jj_la1[5] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OBJECTTYPE_TKN:
        case TC_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          AssignmentList();
          break;
        default:
          jj_la1[6] = jj_gen;
          ;
        }
      } 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);
      }
      }
    }
  
    final public void Exports() throws ParseException {
                    /*@bgen(jjtree) Exports */
    ASTExports jjtn000 = new ASTExports(this, JJTEXPORTS);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(EXPORTS_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OBJECTTYPE_TKN:
        case TC_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          SymbolsExported();
          break;
        default:
          jj_la1[7] = jj_gen;
          ;
        }
        jj_consume_token(SEMI_COLON_TKN);
      } 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);
      }
      }
    }
  
    final public void SymbolsExported() throws ParseException {
                            /*@bgen(jjtree) SymbolsExported */
    ASTSymbolsExported jjtn000 = new ASTSymbolsExported(this, JJTSYMBOLSEXPORTED);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        ExportSymbolList();
      } 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);
       }
      }
    }
  
    final public void ExportSymbolList() throws ParseException {
                             /*@bgen(jjtree) ExportSymbolList */
    ASTExportSymbolList jjtn000 = new ASTExportSymbolList(this, JJTEXPORTSYMBOLLIST);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        Symbol();
        label_2:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA_TKN:
            ;
            break;
          default:
            jj_la1[8] = jj_gen;
            break label_2;
          }
          jj_consume_token(COMMA_TKN);
          Symbol();
        }
      } 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);
       }
      }
    }
  
    final public void Imports() throws ParseException {
                    /*@bgen(jjtree) Imports */
    ASTImports jjtn000 = new ASTImports(this, JJTIMPORTS);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(IMPORTS_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OBJECTTYPE_TKN:
        case TC_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          SymbolsImported();
          break;
        default:
          jj_la1[9] = jj_gen;
          ;
        }
        jj_consume_token(SEMI_COLON_TKN);
      } 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);
       }
      }
    }
  
    final public void SymbolsImported() throws ParseException {
                            /*@bgen(jjtree) SymbolsImported */
    ASTSymbolsImported jjtn000 = new ASTSymbolsImported(this, JJTSYMBOLSIMPORTED);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        SymbolsFromModuleList();
      } 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);
       }
      }
    }
  
    final public void SymbolsFromModuleList() throws ParseException {
                                  /*@bgen(jjtree) SymbolsFromModuleList */
    ASTSymbolsFromModuleList jjtn000 = new ASTSymbolsFromModuleList(this, JJTSYMBOLSFROMMODULELIST);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        SymbolsFromModule();
        label_3:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case OBJECTTYPE_TKN:
          case TC_TKN:
          case LCASEFIRST_IDENT_TKN:
          case UCASEFIRST_IDENT_TKN:
            ;
            break;
          default:
            jj_la1[10] = jj_gen;
            break label_3;
          }
          SymbolsFromModule();
        }
      } 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);
       }
      }
    }
  
    final public void SymbolsFromModule() throws ParseException {
                              /*@bgen(jjtree) SymbolsFromModule */
                               ASTSymbolsFromModule jjtn000 = new ASTSymbolsFromModule(this, JJTSYMBOLSFROMMODULE);
                               boolean jjtc000 = true;
                               jjtree.openNodeScope(jjtn000);String module;
      try {
        SymbolList();
        jj_consume_token(FROM_TKN);
        ModuleIdentifier();
      } 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);
       }
      }
    }
  
    final public void SymbolList() throws ParseException {
                       /*@bgen(jjtree) SymbolList */
    ASTSymbolList jjtn000 = new ASTSymbolList(this, JJTSYMBOLLIST);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        Symbol();
        label_4:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA_TKN:
            ;
            break;
          default:
            jj_la1[11] = jj_gen;
            break label_4;
          }
          jj_consume_token(COMMA_TKN);
          Symbol();
        }
      } 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);
       }
      }
    }
  
    final public void Symbol() throws ParseException {
                   /*@bgen(jjtree) Symbol */
    ASTSymbol jjtn000 = new ASTSymbol(this, JJTSYMBOL);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case UCASEFIRST_IDENT_TKN:
          typereference();
                       jjtree.closeNodeScope(jjtn000, true);
                       jjtc000 = false;
                       jjtn000.which = 1;
          break;
        case LCASEFIRST_IDENT_TKN:
          identifier();
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.which = 2;
          break;
        case OBJECTTYPE_TKN:
        case TC_TKN:
          DefinedMacroName();
                          jjtree.closeNodeScope(jjtn000, true);
                          jjtc000 = false;
                          jjtn000.which = 3;
          break;
        default:
          jj_la1[12] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } 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);
       }
      }
    }
  
    final public void AssignmentList() throws ParseException {
                           /*@bgen(jjtree) AssignmentList */
    ASTAssignmentList jjtn000 = new ASTAssignmentList(this, JJTASSIGNMENTLIST);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        Assignment();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SEMI_COLON_TKN:
          jj_consume_token(SEMI_COLON_TKN);
          break;
        default:
          jj_la1[13] = jj_gen;
          ;
        }
        label_5:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case OBJECTTYPE_TKN:
          case TC_TKN:
          case LCASEFIRST_IDENT_TKN:
          case UCASEFIRST_IDENT_TKN:
            ;
            break;
          default:
            jj_la1[14] = jj_gen;
            break label_5;
          }
          Assignment();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case SEMI_COLON_TKN:
            jj_consume_token(SEMI_COLON_TKN);
            break;
          default:
            jj_la1[15] = jj_gen;
            ;
          }
        }
      } 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);
      }
      }
    }
  
    final public void Assignment() throws ParseException {
                       /*@bgen(jjtree) Assignment */
    ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        if (jj_2_1(2)) {
          MacroDefinition();
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case UCASEFIRST_IDENT_TKN:
            TypeAssignment();
            break;
          case LCASEFIRST_IDENT_TKN:
            ValueAssignment();
            break;
          default:
            jj_la1[16] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      } 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);
       }
      }
    }
  
    final public void MacroDefinition() throws ParseException {
                            /*@bgen(jjtree) MacroDefinition */
    ASTMacroDefinition jjtn000 = new ASTMacroDefinition(this, JJTMACRODEFINITION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TC_TKN:
          jj_consume_token(TC_TKN);
          break;
        case OBJECTTYPE_TKN:
          jj_consume_token(OBJECTTYPE_TKN);
          break;
        case UCASEFIRST_IDENT_TKN:
          typereference();
          break;
        default:
          jj_la1[17] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jj_consume_token(MACRO_TKN);
        jj_consume_token(GETS_TKN);
        jj_consume_token(BEGIN_TKN);
        MacroBody();
        jj_consume_token(END_TKN);
      } 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);
       }
      }
    }
  
    void MacroBody() throws ParseException {
                    /*@bgen(jjtree) MacroBody */
  ASTMacroBody jjtn000 = new ASTMacroBody(this, JJTMACROBODY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  try {Token tok;
    int nesting = 1;
    while (true) {
      tok = getToken(1);
      if (tok.kind == END_TKN) {
          break;
      }
      tok = getNextToken();
    }/*@bgen(jjtree)*/
  } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
  }
    }
  
    final public void MacroReference() throws ParseException {
                           /*@bgen(jjtree) MacroReference */
    ASTMacroReference jjtn000 = new ASTMacroReference(this, JJTMACROREFERENCE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case UCASEFIRST_IDENT_TKN:
          typereference();
          break;
        case OBJECTTYPE_TKN:
        case TC_TKN:
          DefinedMacroName();
          break;
        default:
          jj_la1[18] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } 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);
       }
      }
    }
  
    final public void TypeAssignment() throws ParseException {
                           /*@bgen(jjtree) TypeAssignment */
    ASTTypeAssignment jjtn000 = new ASTTypeAssignment(this, JJTTYPEASSIGNMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        typereference();
        jj_consume_token(GETS_TKN);
        GlobalType();
      } 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);
       }
      }
    }
  
    final public void GlobalType() throws ParseException {
                       /*@bgen(jjtree) GlobalType */
    ASTGlobalType jjtn000 = new ASTGlobalType(this, JJTGLOBALTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OBJECT_IDENTIFIER_TKN:
        case LEFTBRACKET_TKN:
        case BOOLEAN_TKN:
        case INTEGER_TKN:
        case BIT_TKN:
        case OCTET_TKN:
        case NULL_TKN:
        case SEQUENCE_TKN:
        case SET_TKN:
        case CHOICE_TKN:
        case ANY_TKN:
        case ENUMERATED_TKN:
        case REAL_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          Type();
               jjtree.closeNodeScope(jjtn000, true);
               jjtc000 = false;
               jjtn000.which = 1;
          break;
        case OBJECTTYPE_TKN:
        case TC_TKN:
          DefinedMacroType();
                           jjtree.closeNodeScope(jjtn000, true);
                           jjtc000 = false;
                           jjtn000.which = 2;
          break;
        default:
          jj_la1[19] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } 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);
      }
      }
    }
  
    final public void Type() throws ParseException {
                 /*@bgen(jjtree) Type */
    ASTType jjtn000 = new ASTType(this, JJTTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        if (jj_2_2(2)) {
          BuiltinType();
                                    jjtn000.which = 1;
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case UCASEFIRST_IDENT_TKN:
            DefinedType();
                       jjtn000.which = 2;
            break;
          default:
            jj_la1[20] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        if (jj_2_3(2)) {
          SubtypeSpec();
        } else {
          ;
        }
      } 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);
       }
      }
    }
  
    final public void DefinedType() throws ParseException {
                        /*@bgen(jjtree) DefinedType */
    ASTDefinedType jjtn000 = new ASTDefinedType(this, JJTDEFINEDTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        if (jj_2_4(2)) {
          modulereference();
          jj_consume_token(DOT_TKN);
        } else {
          ;
        }
        typereference();
      } 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);
      }
      }
    }
  
    final public void BuiltinType() throws ParseException {
                        /*@bgen(jjtree) BuiltinType */
    ASTBuiltinType jjtn000 = new ASTBuiltinType(this, JJTBUILTINTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INTEGER_TKN:
          IntegerType();
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.which = 0;
          break;
        case BIT_TKN:
          BitStringType();
                      jjtree.closeNodeScope(jjtn000, true);
                      jjtc000 = false;
                      jjtn000.which = 1;
          break;
        default:
          jj_la1[21] = jj_gen;
          if (jj_2_5(2)) {
            SetOrSequenceType();
                                       jjtree.closeNodeScope(jjtn000, true);
                                       jjtc000 = false;
                                       jjtn000.which = 2;
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case SEQUENCE_TKN:
            case SET_TKN:
              SetOrSequenceOfType();
                           jjtree.closeNodeScope(jjtn000, true);
                           jjtc000 = false;
                           jjtn000.which = 3;
              break;
            case CHOICE_TKN:
              ChoiceType();
                   jjtree.closeNodeScope(jjtn000, true);
                   jjtc000 = false;
                   jjtn000.which = 4;
              break;
            case LCASEFIRST_IDENT_TKN:
              SelectionType();
                      jjtree.closeNodeScope(jjtn000, true);
                      jjtc000 = false;
                      jjtn000.which = 5;
              break;
            case LEFTBRACKET_TKN:
              TaggedType();
                   jjtree.closeNodeScope(jjtn000, true);
                   jjtc000 = false;
                   jjtn000.which = 6;
              break;
            case ANY_TKN:
              AnyType();
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                jjtn000.which = 7;
              break;
            case ENUMERATED_TKN:
              EnumeratedType();
                       jjtree.closeNodeScope(jjtn000, true);
                       jjtc000 = false;
                       jjtn000.which = 8;
              break;
            case OCTET_TKN:
              jj_consume_token(OCTET_TKN);
              jj_consume_token(STRING_TKN);
                               jjtree.closeNodeScope(jjtn000, true);
                               jjtc000 = false;
                               jjtn000.which = 9;
              break;
            case OBJECT_IDENTIFIER_TKN:
              jj_consume_token(OBJECT_IDENTIFIER_TKN);
                             jjtree.closeNodeScope(jjtn000, true);
                             jjtc000 = false;
                             jjtn000.which = 10;
              break;
            case REAL_TKN:
              jj_consume_token(REAL_TKN);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                jjtn000.which = 11;
              break;
            case BOOLEAN_TKN:
              jj_consume_token(BOOLEAN_TKN);
                   jjtree.closeNodeScope(jjtn000, true);
                   jjtc000 = false;
                   jjtn000.which = 12;
              break;
            case NULL_TKN:
              jj_consume_token(NULL_TKN);
                 jjtree.closeNodeScope(jjtn000, true);
                 jjtc000 = false;
                 jjtn000.which = 13;
              break;
            default:
              jj_la1[22] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
        }
      } 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);
      }
      }
    }
  
    final public void EnumeratedType() throws ParseException {
                           /*@bgen(jjtree) EnumeratedType */
    ASTEnumeratedType jjtn000 = new ASTEnumeratedType(this, JJTENUMERATEDTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(ENUMERATED_TKN);
        jj_consume_token(LEFTBRACE_TKN);
        NamedNumberList();
        jj_consume_token(RIGHTBRACE_TKN);
      } 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);
       }
      }
    }
  
    final public void IntegerType() throws ParseException {
                        /*@bgen(jjtree) IntegerType */
    ASTIntegerType jjtn000 = new ASTIntegerType(this, JJTINTEGERTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(INTEGER_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LEFTBRACE_TKN:
          jj_consume_token(LEFTBRACE_TKN);
                                     jjtn000.hasnames = true;
          NamedNumberList();
          jj_consume_token(RIGHTBRACE_TKN);
          break;
        default:
          jj_la1[23] = jj_gen;
          ;
        }
      } 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);
     }
      }
    }
  
    final public void BitStringType() throws ParseException {
                          /*@bgen(jjtree) BitStringType */
    ASTBitStringType jjtn000 = new ASTBitStringType(this, JJTBITSTRINGTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(BIT_TKN);
        jj_consume_token(STRING_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LEFTBRACE_TKN:
          jj_consume_token(LEFTBRACE_TKN);
                                               jjtn000.hasnames = true;
          NamedNumberList();
          jj_consume_token(RIGHTBRACE_TKN);
          break;
        default:
          jj_la1[24] = jj_gen;
          ;
        }
      } 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);
      }
      }
    }
  
    final public void NamedNumberList() throws ParseException {
                            /*@bgen(jjtree) NamedNumberList */
    ASTNamedNumberList jjtn000 = new ASTNamedNumberList(this, JJTNAMEDNUMBERLIST);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        NamedNumber();
        label_6:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA_TKN:
            ;
            break;
          default:
            jj_la1[25] = jj_gen;
            break label_6;
          }
          jj_consume_token(COMMA_TKN);
          NamedNumber();
        }
      } 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);
      }
      }
    }
  
    final public void NamedNumber() throws ParseException {
                        /*@bgen(jjtree) NamedNumber */
    ASTNamedNumber jjtn000 = new ASTNamedNumber(this, JJTNAMEDNUMBER);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        identifier();
        jj_consume_token(LEFTPAREN_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NUMBER_ERANGE_TKN:
        case NUMBER_TKN:
        case MINUS_TKN:
          SignedNumber();
                                                    jjtn000.which=1;
          break;
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          DefinedValue();
                                                                                          jjtn000.which=2;
          break;
        default:
          jj_la1[26] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jj_consume_token(RIGHTPAREN_TKN);
      } 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);
      }
      }
    }
  
    final public void SignedNumber() throws ParseException {
                         /*@bgen(jjtree) SignedNumber */
                          ASTSignedNumber jjtn000 = new ASTSignedNumber(this, JJTSIGNEDNUMBER);
                          boolean jjtc000 = true;
                          jjtree.openNodeScope(jjtn000);Token t;
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case MINUS_TKN:
          jj_consume_token(MINUS_TKN);
                  jjtn000.is_neg = true;
          break;
        default:
          jj_la1[27] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NUMBER_TKN:
          t = jj_consume_token(NUMBER_TKN);
                                                                     jjtree.closeNodeScope(jjtn000, true);
                                                                     jjtc000 = false;
                                                                     jjtn000.number = t.image;
          break;
        case NUMBER_ERANGE_TKN:
          t = jj_consume_token(NUMBER_ERANGE_TKN);
                                                                            jjtree.closeNodeScope(jjtn000, true);
                                                                            jjtc000 = false;
                                                                            jjtn000.number = t.image;
          break;
        default:
          jj_la1[28] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
      }
      }
    }
  
    final public void SetOrSequenceOfType() throws ParseException {
                                /*@bgen(jjtree) SetOrSequenceOfType */
    ASTSetOrSequenceOfType jjtn000 = new ASTSetOrSequenceOfType(this, JJTSETORSEQUENCEOFTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SET_TKN:
          jj_consume_token(SET_TKN);
                   jjtn000.which = 1;
          break;
        case SEQUENCE_TKN:
          jj_consume_token(SEQUENCE_TKN);
                                                           jjtn000.which = 2;
          break;
        default:
          jj_la1[29] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LEFTPAREN_TKN:
        case SIZE_TKN:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LEFTPAREN_TKN:
            jj_consume_token(LEFTPAREN_TKN);
            break;
          default:
            jj_la1[30] = jj_gen;
            ;
          }
                                                                                                       jjtn000.has_size_constraint = true;
          SizeConstraint();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case RIGHTPAREN_TKN:
            jj_consume_token(RIGHTPAREN_TKN);
            break;
          default:
            jj_la1[31] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[32] = jj_gen;
          ;
        }
        jj_consume_token(OF_TKN);
        Type();
      } 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);
       }
      }
    }
  
    final public void SetOrSequenceType() throws ParseException {
                              /*@bgen(jjtree) SetOrSequenceType */
    ASTSetOrSequenceType jjtn000 = new ASTSetOrSequenceType(this, JJTSETORSEQUENCETYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SET_TKN:
          jj_consume_token(SET_TKN);
                 jjtn000.which = 1;
          break;
        case SEQUENCE_TKN:
          jj_consume_token(SEQUENCE_TKN);
                                                         jjtn000.which = 2;
          break;
        default:
          jj_la1[33] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jj_consume_token(LEFTBRACE_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OBJECT_IDENTIFIER_TKN:
        case LEFTBRACKET_TKN:
        case BOOLEAN_TKN:
        case INTEGER_TKN:
        case BIT_TKN:
        case OCTET_TKN:
        case NULL_TKN:
        case SEQUENCE_TKN:
        case SET_TKN:
        case CHOICE_TKN:
        case ANY_TKN:
        case COMPONENTS_TKN:
        case ENUMERATED_TKN:
        case REAL_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          ElementTypeList();
          break;
        default:
          jj_la1[34] = jj_gen;
          ;
        }
        jj_consume_token(RIGHTBRACE_TKN);
      } 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);
      }
      }
    }
  
    final public void ChoiceType() throws ParseException {
                       /*@bgen(jjtree) ChoiceType */
    ASTChoiceType jjtn000 = new ASTChoiceType(this, JJTCHOICETYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(CHOICE_TKN);
        jj_consume_token(LEFTBRACE_TKN);
        ElementTypeList();
        jj_consume_token(RIGHTBRACE_TKN);
      } 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);
       }
      }
    }
  
    final public void ElementTypeList() throws ParseException {
                            /*@bgen(jjtree) ElementTypeList */
    ASTElementTypeList jjtn000 = new ASTElementTypeList(this, JJTELEMENTTYPELIST);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        ElementType();
        label_7:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA_TKN:
            ;
            break;
          default:
            jj_la1[35] = jj_gen;
            break label_7;
          }
          jj_consume_token(COMMA_TKN);
          ElementType();
        }
      } 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);
       }
      }
    }
  
    final public void ElementType() throws ParseException {
                        /*@bgen(jjtree) ElementType */
    ASTElementType jjtn000 = new ASTElementType(this, JJTELEMENTTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OBJECT_IDENTIFIER_TKN:
        case LEFTBRACKET_TKN:
        case BOOLEAN_TKN:
        case INTEGER_TKN:
        case BIT_TKN:
        case OCTET_TKN:
        case NULL_TKN:
        case SEQUENCE_TKN:
        case SET_TKN:
        case CHOICE_TKN:
        case ANY_TKN:
        case ENUMERATED_TKN:
        case REAL_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          NamedType();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case OPTIONAL_TKN:
          case DEFAULT_TKN:
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case OPTIONAL_TKN:
              jj_consume_token(OPTIONAL_TKN);
                                          jjtn000.optional = true;
              break;
            case DEFAULT_TKN:
              jj_consume_token(DEFAULT_TKN);
              NamedValue();
                                                      jjtn000.has_default = true;
              break;
            default:
              jj_la1[36] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
            break;
          default:
            jj_la1[37] = jj_gen;
            ;
          }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.which = 1;
          break;
        case COMPONENTS_TKN:
          ComponentsType();
                       jjtree.closeNodeScope(jjtn000, true);
                       jjtc000 = false;
                       jjtn000.which = 2;
          break;
        default:
          jj_la1[38] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } 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);
      }
      }
    }
  
    final public void ComponentsType() throws ParseException {
                           /*@bgen(jjtree) ComponentsType */
    ASTComponentsType jjtn000 = new ASTComponentsType(this, JJTCOMPONENTSTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(COMPONENTS_TKN);
        jj_consume_token(OF_TKN);
        Type();
      } 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);
      }
      }
    }
  
    final public void NamedType() throws ParseException {
                      /*@bgen(jjtree) NamedType */
    ASTNamedType jjtn000 = new ASTNamedType(this, JJTNAMEDTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        if (jj_2_6(2)) {
          identifier();
                                 jjtn000.hasid = true;
        } else {
          ;
        }
        Type();
      } 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);
      }
      }
    }
  
    final public void SelectionType() throws ParseException {
                          /*@bgen(jjtree) SelectionType */
    ASTSelectionType jjtn000 = new ASTSelectionType(this, JJTSELECTIONTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        identifier();
        jj_consume_token(LESSTHAN_TKN);
        Type();
      } 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);
       }
      }
    }
  
    final public void TaggedType() throws ParseException {
                       /*@bgen(jjtree) TaggedType */
    ASTTaggedType jjtn000 = new ASTTaggedType(this, JJTTAGGEDTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        Tag();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IMPLICIT_TKN:
        case EXPLICIT_TKN:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case EXPLICIT_TKN:
            jj_consume_token(EXPLICIT_TKN);
                             jjtn000.imporexp = 0;
            break;
          case IMPLICIT_TKN:
            jj_consume_token(IMPLICIT_TKN);
                                                                         jjtn000.imporexp = 1;
            break;
          default:
            jj_la1[39] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[40] = jj_gen;
          ;
        }
        Type();
      } 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);
      }
      }
    }
  
    final public void Tag() throws ParseException {
                /*@bgen(jjtree) Tag */
    ASTTag jjtn000 = new ASTTag(this, JJTTAG);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(LEFTBRACKET_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case UNIVERSAL_TKN:
        case APPLICATION_TKN:
        case PRIVATE_TKN:
          Class();
                                  jjtn000.hasTagClass=true;
          break;
        default:
          jj_la1[41] = jj_gen;
          ;
        }
        ClassNumber();
        jj_consume_token(RIGHTBRACKET_TKN);
      } 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);
       }
      }
    }
  
    final public void ClassNumber() throws ParseException {
                        /*@bgen(jjtree) ClassNumber */
    ASTClassNumber jjtn000 = new ASTClassNumber(this, JJTCLASSNUMBER);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NUMBER_ERANGE_TKN:
        case NUMBER_TKN:
          number();
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                jjtn000.which=1;
          break;
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          DefinedValue();
                                                      jjtree.closeNodeScope(jjtn000, true);
                                                      jjtc000 = false;
                                                      jjtn000.which=2;
          break;
        default:
          jj_la1[42] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } 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);
       }
      }
    }
  
    final public void Class() throws ParseException {
                  /*@bgen(jjtree) Class */
    ASTClass jjtn000 = new ASTClass(this, JJTCLASS);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case UNIVERSAL_TKN:
          jj_consume_token(UNIVERSAL_TKN);
                       jjtree.closeNodeScope(jjtn000, true);
                       jjtc000 = false;
                       jjtn000.tag_class = 0x00;
          break;
        case APPLICATION_TKN:
          jj_consume_token(APPLICATION_TKN);
                         jjtree.closeNodeScope(jjtn000, true);
                         jjtc000 = false;
                         jjtn000.tag_class = 0x40;
          break;
        case PRIVATE_TKN:
          jj_consume_token(PRIVATE_TKN);
                     jjtree.closeNodeScope(jjtn000, true);
                     jjtc000 = false;
                     jjtn000.tag_class = 0xC0;
          break;
        default:
          jj_la1[43] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } finally {
       if (jjtc000) {
         jjtree.closeNodeScope(jjtn000, true);
       }
      }
    }
  
    final public void AnyType() throws ParseException {
                    /*@bgen(jjtree) AnyType */
    ASTAnyType jjtn000 = new ASTAnyType(this, JJTANYTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(ANY_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DEFINED_TKN:
          jj_consume_token(DEFINED_TKN);
          jj_consume_token(BY_TKN);
          identifier();
          break;
        default:
          jj_la1[44] = jj_gen;
          ;
        }
      } 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);
      }
      }
    }
  
    final public void SubtypeSpec() throws ParseException {
                        /*@bgen(jjtree) SubtypeSpec */
    ASTSubtypeSpec jjtn000 = new ASTSubtypeSpec(this, JJTSUBTYPESPEC);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(LEFTPAREN_TKN);
        SubtypeValueSetList();
        jj_consume_token(RIGHTPAREN_TKN);
      } 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);
       }
      }
    }
  
    final public void SubtypeValueSetList() throws ParseException {
                                /*@bgen(jjtree) SubtypeValueSetList */
    ASTSubtypeValueSetList jjtn000 = new ASTSubtypeValueSetList(this, JJTSUBTYPEVALUESETLIST);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        SubtypeValueSet();
        label_8:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case BAR_TKN:
            ;
            break;
          default:
            jj_la1[45] = jj_gen;
            break label_8;
          }
          jj_consume_token(BAR_TKN);
          SubtypeValueSet();
        }
      } 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);
       }
      }
    }
  
    final public void SubtypeValueSet() throws ParseException {
                            /*@bgen(jjtree) SubtypeValueSet */
    ASTSubtypeValueSet jjtn000 = new ASTSubtypeValueSet(this, JJTSUBTYPEVALUESET);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BSTRING_TKN:
        case HSTRING_TKN:
        case CSTRING_TKN:
        case NUMBER_ERANGE_TKN:
        case NUMBER_TKN:
        case LEFTBRACE_TKN:
        case MINUS_TKN:
        case NULL_TKN:
        case TRUE_TKN:
        case FALSE_TKN:
        case MIN_TKN:
        case PLUS_INFINITY_TKN:
        case MINUS_INFINITY_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          ValueRange();
          break;
        case INCLUDES_TKN:
          ContainedSubtype();
          break;
        case FROM_TKN:
          PermittedAlphabet();
          break;
        case SIZE_TKN:
          SizeConstraint();
          break;
        case WITH_TKN:
          InnerTypeConstraints();
          break;
        default:
          jj_la1[46] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } 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);
     }
      }
    }
  
    final public void ContainedSubtype() throws ParseException {
                             /*@bgen(jjtree) ContainedSubtype */
    ASTContainedSubtype jjtn000 = new ASTContainedSubtype(this, JJTCONTAINEDSUBTYPE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(INCLUDES_TKN);
        Type();
      } 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);
       }
      }
    }
  
    final public void SingleValue() throws ParseException {
                        /*@bgen(jjtree) SingleValue */
    ASTSingleValue jjtn000 = new ASTSingleValue(this, JJTSINGLEVALUE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        Value();
      } 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);
       }
      }
    }
  
    final public void ValueRange() throws ParseException {
                       /*@bgen(jjtree) ValueRange */
    ASTValueRange jjtn000 = new ASTValueRange(this, JJTVALUERANGE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BSTRING_TKN:
        case HSTRING_TKN:
        case CSTRING_TKN:
        case NUMBER_ERANGE_TKN:
        case NUMBER_TKN:
        case LEFTBRACE_TKN:
        case MINUS_TKN:
        case NULL_TKN:
        case TRUE_TKN:
        case FALSE_TKN:
        case PLUS_INFINITY_TKN:
        case MINUS_INFINITY_TKN:
        case LCASEFIRST_IDENT_TKN:
        case UCASEFIRST_IDENT_TKN:
          Value();
          break;
        case MIN_TKN:
          jj_consume_token(MIN_TKN);
          break;
        default:
          jj_la1[47] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DOT_TKN:
        case LESSTHAN_TKN:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LESSTHAN_TKN:
            jj_consume_token(LESSTHAN_TKN);
            break;
          default:
            jj_la1[48] = jj_gen;
            ;
          }
          jj_consume_token(DOT_TKN);
          jj_consume_token(DOT_TKN);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LESSTHAN_TKN:
            jj_consume_token(LESSTHAN_TKN);
            break;
          default:
            jj_la1[49] = jj_gen;
            ;
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case BSTRING_TKN:
          case HSTRING_TKN:
          case CSTRING_TKN:
          case NUMBER_ERANGE_TKN:
          case NUMBER_TKN:
          case LEFTBRACE_TKN:
          case MINUS_TKN:
          case NULL_TKN:
          case TRUE_TKN:
          case FALSE_TKN:
          case PLUS_INFINITY_TKN:
          case MINUS_INFINITY_TKN:
          case LCASEFIRST_IDENT_TKN:
          case UCASEFIRST_IDENT_TKN:
            Value();
            break;
          case MAX_TKN:
            jj_consume_token(MAX_TKN);
            break;
          default:
            jj_la1[50] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[51] = jj_gen;
          ;
        }
      } 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);
     }
      }
    }
  
    final public void SizeConstraint() throws ParseException {
                           /*@bgen(jjtree) SizeConstraint */
    ASTSizeConstraint jjtn000 = new ASTSizeConstraint(this, JJTSIZECONSTRAINT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(SIZE_TKN);
        SubtypeSpec();
      } 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);
       }
      }
    }
  
    final public void PermittedAlphabet() throws ParseException {
                              /*@bgen(jjtree) PermittedAlphabet */
    ASTPermittedAlphabet jjtn000 = new ASTPermittedAlphabet(this, JJTPERMITTEDALPHABET);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(FROM_TKN);
        SubtypeSpec();
      } 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);
       }
      }
    }
  
    final public void InnerTypeConstraints() throws ParseException {
                                 /*@bgen(jjtree) InnerTypeConstraints */
    ASTInnerTypeConstraints jjtn000 = new ASTInnerTypeConstraints(this, JJTINNERTYPECONSTRAINTS);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
      try {
        jj_consume_token(WITH_TKN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMPONENT_TKN:
          jj_consume_token(COMPONENT_TKN);
          SingleTypeConstraint();
          break;
        case COMPONENTS_TKN:
          jj_consume_token(COMPONENTS_TKN);
          MultipleTypeConstraints();
          break;
        default:
          jj_la1[52] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      } catch (Throwable jjte000) {
  