/* Generated By:JJTree&JavaCC: Do not edit this line. XPath.java */
        package org.apache.jackrabbit.spi.commons.query.xpath;

import java.io.*;
import java.util.Stack;
import java.util.Vector;

public class XPath/*@bgen(jjtree)*/implements XPathTreeConstants, XPathConstants {/*@bgen(jjtree)*/
  protected JJTXPathState jjtree = new JJTXPathState();

      boolean m_isMatchPattern = false;
      boolean isStep = false;

                  Stack binaryTokenStack = new Stack();

                  public Node createNode(int id) {
                          return null;
                  }



                  public static void main(String args[])
                     throws Exception
                  {
         int numberArgsLeft = args.length;
         int argsStart = 0;
         boolean isMatchParser = false;
         if(numberArgsLeft > 0)
         {
           if(args[argsStart].equals("-match"))
           {
             isMatchParser = true;
             System.out.println("Match Pattern Parser");
             argsStart++;
             numberArgsLeft--;
           }
         }
                     if(numberArgsLeft > 0)
                    {
                        try
                        {
        final boolean dumpTree = true;
        if(args[0].endsWith(".xquery"))
        {
          System.out.println("Running test for: "+args[0]);
          File file = new File(args[0]);
          FileInputStream fis = new FileInputStream(file);
          XPath parser = new XPath(fis);
          SimpleNode tree = parser.XPath2();
          if(dumpTree)
            tree.dump("|") ;
        }
        else
        {
                                for(int i = argsStart; i < args.length; i++)
                                {
                                        System.out.println();
                                        System.out.println("Test["+i+"]: "+args[i]);
                                        XPath parser = new XPath(new java.io.StringBufferInputStream(args[i]));
          SimpleNode tree;
          if(isMatchParser)
          {
                                        tree = parser.XPath2();
          }
          else
          {
                                        tree = parser.XPath2();
          }
                                        ((SimpleNode)tree.jjtGetChild(0)).dump("|") ;
                                }
                                System.out.println("Success!!!!");
        }
                        }
                        catch(ParseException pe)
                        {
                                System.err.println(pe.getMessage());
                        }
                        return;
                   }
                    java.io.DataInputStream dinput = new java.io.DataInputStream(System.in);
                    while(true)
                    {
                          try
                          {
                              System.err.println("Type Expression: ");
                              String input =  dinput.readLine();
                              if(null == input || input.trim().length() == 0)
                                break;
                              XPath parser = new XPath(new java.io.StringBufferInputStream(input));
          SimpleNode tree;
          if(isMatchParser)
          {
                                        tree = parser.XPath2();
          }
          else
          {
                                        tree = parser.XPath2();
          }
                              ((SimpleNode)tree.jjtGetChild(0)).dump("|") ;
                          }
                          catch(ParseException pe)
                          {
                                System.err.println(pe.getMessage());
                          }
                          catch(Exception e)
                          {
                                System.err.println(e.getMessage());
                          }
                    }
                  }

  final public SimpleNode XPath2() throws ParseException {
                 /*@bgen(jjtree) XPath2 */
  SimpleNode jjtn000 = new SimpleNode(this, JJTXPATH2);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      QueryList();
      jj_consume_token(0);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    {if (true) return jjtn000 ;}
    } 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);
                    }
    }
    throw new Error("Missing return statement in function");
  }

  final public void QueryList() throws ParseException {
 /*@bgen(jjtree) QueryList */
  SimpleNode jjtn000 = new SimpleNode(this, JJTQUERYLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Module();
      label_1:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case QuerySeparator:
          ;
          break;
        default:
          jj_la1[0] = jj_gen;
          break label_1;
        }
        jj_consume_token(QuerySeparator);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IntegerLiteral:
        case DecimalLiteral:
        case DoubleLiteral:
        case StringLiteral:
        case XQueryVersion:
        case ModuleNamespace:
        case ProcessingInstructionStart:
        case ProcessingInstructionStartForElementContent:
        case AxisChild:
        case AxisDescendant:
        case AxisParent:
        case AxisAttribute:
        case AxisSelf:
        case AxisDescendantOrSelf:
        case AxisAncestor:
        case AxisFollowingSibling:
        case AxisPrecedingSibling:
        case AxisFollowing:
        case AxisPreceding:
        case AxisAncestorOrSelf:
        case DefineFunction:
        case DeclareOrdering:
        case DeclareDefaultOrderingEmpty:
        case DeclareInheritNamespaces:
        case VariableIndicator:
        case DeclareConstruction:
        case DeclareXMLSpace:
        case DeclareBaseURI:
        case DeclareNamespace:
        case ElementType:
        case AttributeType:
        case SchemaElementType:
        case SchemaAttributeType:
        case OrderedOpen:
        case UnorderedOpen:
        case ElementQNameLbrace:
        case AttributeQNameLbrace:
        case PINCNameLbrace:
        case PILbrace:
        case CommentLbrace:
        case ElementLbrace:
        case AttributeLbrace:
        case TextLbrace:
        case DeclareCollation:
        case DeclareDefaultElement:
        case DeclareDefaultFunction:
        case ImportSchemaToken:
        case ImportModuleToken:
        case Star:
        case NCNameColonStar:
        case StarColonNCName:
        case Root:
        case RootDescendants:
        case UnaryMinus:
        case UnaryPlus:
        case Lpar:
        case At:
        case Some:
        case Every:
        case ForVariable:
        case LetVariable:
        case ValidateLbrace:
        case ValidateSchemaMode:
        case DocumentLpar:
        case DocumentLparForKindTest:
        case DocumentLbrace:
        case NodeLpar:
        case CommentLpar:
        case TextLpar:
        case ProcessingInstructionLpar:
        case ElementTypeForKindTest:
        case ElementTypeForDocumentTest:
        case AttributeTypeForKindTest:
        case SchemaElementTypeForKindTest:
        case SchemaElementTypeForDocumentTest:
        case SchemaAttributeTypeForKindTest:
        case ProcessingInstructionLparForKindTest:
        case TextLparForKindTest:
        case CommentLparForKindTest:
        case NodeLparForKindTest:
        case IfLpar:
        case TypeswitchLpar:
        case Dot:
        case DotDot:
        case DefineVariable:
        case QNameLpar:
        case StartTagOpen:
        case StartTagOpenRoot:
        case XmlCommentStart:
        case XmlCommentStartForElementContent:
        case QName:
          Module();
          break;
        default:
          jj_la1[1] = 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 Module() throws ParseException {
 /*@bgen(jjtree) Module */
  SimpleNode jjtn000 = new SimpleNode(this, JJTMODULE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case XQueryVersion:
        VersionDecl();
        break;
      default:
        jj_la1[2] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case DefineFunction:
      case DeclareOrdering:
      case DeclareDefaultOrderingEmpty:
      case DeclareInheritNamespaces:
      case VariableIndicator:
      case DeclareConstruction:
      case DeclareXMLSpace:
      case DeclareBaseURI:
      case DeclareNamespace:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case OrderedOpen:
      case UnorderedOpen:
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case DeclareCollation:
      case DeclareDefaultElement:
      case DeclareDefaultFunction:
      case ImportSchemaToken:
      case ImportModuleToken:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Root:
      case RootDescendants:
      case UnaryMinus:
      case UnaryPlus:
      case Lpar:
      case At:
      case Some:
      case Every:
      case ForVariable:
      case LetVariable:
      case ValidateLbrace:
      case ValidateSchemaMode:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case DocumentLbrace:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case IfLpar:
      case TypeswitchLpar:
      case Dot:
      case DotDot:
      case DefineVariable:
      case QNameLpar:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
      case QName:
        MainModule();
        break;
      case ModuleNamespace:
        LibraryModule();
        break;
      default:
        jj_la1[3] = 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 VersionDecl() throws ParseException {
 /*@bgen(jjtree) VersionDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTVERSIONDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(XQueryVersion);
                   SimpleNode jjtn001 = new SimpleNode(this, JJTXQUERYVERSION);
                   boolean jjtc001 = true;
                   jjtree.openNodeScope(jjtn001);
      try {
                   jjtree.closeNodeScope(jjtn001,  true);
                   jjtc001 = false;
                  jjtn001.processToken(token);
      } finally {
                   if (jjtc001) {
                     jjtree.closeNodeScope(jjtn001,  true);
                   }
      }
      jj_consume_token(StringLiteralForVersion);
                                                                                                SimpleNode jjtn002 = new SimpleNode(this, JJTSTRINGLITERALFORVERSION);
                                                                                                boolean jjtc002 = true;
                                                                                                jjtree.openNodeScope(jjtn002);
      try {
                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                                jjtc002 = false;
                                                                          jjtn002.processToken(token);
      } finally {
                                                                                                if (jjtc002) {
                                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                                }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case XQueryEncoding:
        jj_consume_token(XQueryEncoding);
                                                                                                                                                                               SimpleNode jjtn003 = new SimpleNode(this, JJTXQUERYENCODING);
                                                                                                                                                                               boolean jjtc003 = true;
                                                                                                                                                                               jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               jjtc003 = false;
                                                                                                                          jjtn003.processToken(token);
        } finally {
                                                                                                                                                                               if (jjtc003) {
                                                                                                                                                                                 jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               }
        }
        jj_consume_token(StringLiteralForVersion);
                                                                                                                                                                                                                                                             SimpleNode jjtn004 = new SimpleNode(this, JJTSTRINGLITERALFORVERSION);
                                                                                                                                                                                                                                                             boolean jjtc004 = true;
                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                             jjtc004 = false;
                                                                                                                                                                                  jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                                             if (jjtc004) {
                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                             }
        }
        break;
      default:
        jj_la1[4] = jj_gen;
        ;
      }
      Separator();
    } 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 MainModule() throws ParseException {
 /*@bgen(jjtree) MainModule */
  SimpleNode jjtn000 = new SimpleNode(this, JJTMAINMODULE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Prolog();
      QueryBody();
    } 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 LibraryModule() throws ParseException {
 /*@bgen(jjtree) LibraryModule */
  SimpleNode jjtn000 = new SimpleNode(this, JJTLIBRARYMODULE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ModuleDecl();
      Prolog();
    } 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 ModuleDecl() throws ParseException {
 /*@bgen(jjtree) ModuleDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTMODULEDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(ModuleNamespace);
                     SimpleNode jjtn001 = new SimpleNode(this, JJTMODULENAMESPACE);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
      try {
                     jjtree.closeNodeScope(jjtn001,  true);
                     jjtc001 = false;
                    jjtn001.processToken(token);
      } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  true);
                     }
      }
      jj_consume_token(NCNameForPrefix);
                                                                                            SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
                                                                                            boolean jjtc002 = true;
                                                                                            jjtree.openNodeScope(jjtn002);
      try {
                                                                                            jjtree.closeNodeScope(jjtn002,  true);
                                                                                            jjtc002 = false;
                                                                    jjtn002.processToken(token);
      } finally {
                                                                                            if (jjtc002) {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                            }
      }
      jj_consume_token(AssignEquals);
                                                                                                                                                                SimpleNode jjtn003 = new SimpleNode(this, JJTASSIGNEQUALS);
                                                                                                                                                                boolean jjtc003 = true;
                                                                                                                                                                jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                jjtc003 = false;
                                                                                                                 jjtn003.processToken(token);
      } finally {
                                                                                                                                                                if (jjtc003) {
                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                }
      }
      jj_consume_token(URLLiteral);
                                                                                                                                                                                                                               SimpleNode jjtn004 = new SimpleNode(this, JJTURLLITERAL);
                                                                                                                                                                                                                               boolean jjtc004 = true;
                                                                                                                                                                                                                               jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                               jjtc004 = false;
                                                                                                                                                            jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                                                               if (jjtc004) {
                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                               }
      }
      Separator();
    } 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 Prolog() throws ParseException {
 /*@bgen(jjtree) Prolog */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPROLOG);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_2:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DeclareOrdering:
        case DeclareDefaultOrderingEmpty:
        case DeclareInheritNamespaces:
        case DeclareConstruction:
        case DeclareXMLSpace:
        case DeclareBaseURI:
        case DeclareCollation:
          ;
          break;
        default:
          jj_la1[5] = jj_gen;
          break label_2;
        }
        Setter();
        Separator();
      }
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DeclareNamespace:
        case DeclareDefaultElement:
        case DeclareDefaultFunction:
        case ImportSchemaToken:
        case ImportModuleToken:
          ;
          break;
        default:
          jj_la1[6] = jj_gen;
          break label_3;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ImportSchemaToken:
        case ImportModuleToken:
          Import();
          break;
        case DeclareNamespace:
          NamespaceDecl();
          break;
        case DeclareDefaultElement:
        case DeclareDefaultFunction:
          DefaultNamespaceDecl();
          break;
        default:
          jj_la1[7] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        Separator();
      }
      label_4:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DefineFunction:
        case DefineVariable:
          ;
          break;
        default:
          jj_la1[8] = jj_gen;
          break label_4;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DefineVariable:
          VarDecl();
          break;
        case DefineFunction:
          FunctionDecl();
          break;
        default:
          jj_la1[9] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        Separator();
      }
    } 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 Setter() throws ParseException {
 /*@bgen(jjtree) Setter */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSETTER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DeclareXMLSpace:
        XMLSpaceDecl();
        break;
      case DeclareCollation:
        DefaultCollationDecl();
        break;
      case DeclareBaseURI:
        BaseURIDecl();
        break;
      case DeclareConstruction:
        ConstructionDecl();
        break;
      case DeclareOrdering:
        OrderingModeDecl();
        break;
      case DeclareDefaultOrderingEmpty:
        EmptyOrderingDecl();
        break;
      case DeclareInheritNamespaces:
        InheritNamespacesDecl();
        break;
      default:
        jj_la1[10] = 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 Import() throws ParseException {
 /*@bgen(jjtree) Import */
  SimpleNode jjtn000 = new SimpleNode(this, JJTIMPORT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ImportSchemaToken:
        SchemaImport();
        break;
      case ImportModuleToken:
        ModuleImport();
        break;
      default:
        jj_la1[11] = 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 Separator() throws ParseException {
 /*@bgen(jjtree) Separator */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSEPARATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(SemiColon);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void NamespaceDecl() throws ParseException {
 /*@bgen(jjtree) NamespaceDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTNAMESPACEDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareNamespace);
                      SimpleNode jjtn001 = new SimpleNode(this, JJTDECLARENAMESPACE);
                      boolean jjtc001 = true;
                      jjtree.openNodeScope(jjtn001);
      try {
                      jjtree.closeNodeScope(jjtn001,  true);
                      jjtc001 = false;
                     jjtn001.processToken(token);
      } finally {
                      if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001,  true);
                      }
      }
      jj_consume_token(NCNameForPrefix);
                                                                                              SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
                                                                                              boolean jjtc002 = true;
                                                                                              jjtree.openNodeScope(jjtn002);
      try {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                              jjtc002 = false;
                                                                     jjtn002.processToken(token);
      } finally {
                                                                                              if (jjtc002) {
                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                              }
      }
      jj_consume_token(AssignEquals);
                                                                                                                                                                  SimpleNode jjtn003 = new SimpleNode(this, JJTASSIGNEQUALS);
                                                                                                                                                                  boolean jjtc003 = true;
                                                                                                                                                                  jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                  jjtc003 = false;
                                                                                                                  jjtn003.processToken(token);
      } finally {
                                                                                                                                                                  if (jjtc003) {
                                                                                                                                                                    jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                  }
      }
      jj_consume_token(URLLiteral);
                                                                                                                                                                                                                                 SimpleNode jjtn004 = new SimpleNode(this, JJTURLLITERAL);
                                                                                                                                                                                                                                 boolean jjtc004 = true;
                                                                                                                                                                                                                                 jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                 jjtc004 = false;
                                                                                                                                                             jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                                                                 if (jjtc004) {
                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                 }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void XMLSpaceDecl() throws ParseException {
 /*@bgen(jjtree) XMLSpaceDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTXMLSPACEDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareXMLSpace);
                     SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREXMLSPACE);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
      try {
                     jjtree.closeNodeScope(jjtn001,  true);
                     jjtc001 = false;
                    jjtn001.processToken(token);
      } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  true);
                     }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case XMLSpacePreserve:
        jj_consume_token(XMLSpacePreserve);
                                                                                              SimpleNode jjtn002 = new SimpleNode(this, JJTXMLSPACEPRESERVE);
                                                                                              boolean jjtc002 = true;
                                                                                              jjtree.openNodeScope(jjtn002);
        try {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                              jjtc002 = false;
                                                                      jjtn002.processToken(token);
        } finally {
                                                                                              if (jjtc002) {
                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                              }
        }
        break;
      case XMLSpaceStrip:
        jj_consume_token(XMLSpaceStrip);
                                                                                                                                                                      SimpleNode jjtn003 = new SimpleNode(this, JJTXMLSPACESTRIP);
                                                                                                                                                                      boolean jjtc003 = true;
                                                                                                                                                                      jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                      jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                      jjtc003 = false;
                                                                                                                      jjtn003.processToken(token);
        } finally {
                                                                                                                                                                      if (jjtc003) {
                                                                                                                                                                        jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                      }
        }
        break;
      default:
        jj_la1[12] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void DefaultNamespaceDecl() throws ParseException {
 /*@bgen(jjtree) DefaultNamespaceDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDEFAULTNAMESPACEDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DeclareDefaultElement:
        jj_consume_token(DeclareDefaultElement);
                            SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREDEFAULTELEMENT);
                            boolean jjtc001 = true;
                            jjtree.openNodeScope(jjtn001);
        try {
                            jjtree.closeNodeScope(jjtn001,  true);
                            jjtc001 = false;
                           jjtn001.processToken(token);
        } finally {
                            if (jjtc001) {
                              jjtree.closeNodeScope(jjtn001,  true);
                            }
        }
        break;
      case DeclareDefaultFunction:
        jj_consume_token(DeclareDefaultFunction);
                                                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTDECLAREDEFAULTFUNCTION);
                                                                                                                  boolean jjtc002 = true;
                                                                                                                  jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                  jjtc002 = false;
                                                                                    jjtn002.processToken(token);
        } finally {
                                                                                                                  if (jjtc002) {
                                                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                  }
        }
        break;
      default:
        jj_la1[13] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(Namespace);
                                                                                                                                                                                           SimpleNode jjtn003 = new SimpleNode(this, JJTNAMESPACE);
                                                                                                                                                                                           boolean jjtc003 = true;
                                                                                                                                                                                           jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                                           jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                           jjtc003 = false;
                                                                                                                               jjtn003.processToken(token);
      } finally {
                                                                                                                                                                                           if (jjtc003) {
                                                                                                                                                                                             jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                           }
      }
      jj_consume_token(URLLiteral);
                                                                                                                                                                                                                                                       SimpleNode jjtn004 = new SimpleNode(this, JJTURLLITERAL);
                                                                                                                                                                                                                                                       boolean jjtc004 = true;
                                                                                                                                                                                                                                                       jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                       jjtc004 = false;
                                                                                                                                                                          jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                                                                                       if (jjtc004) {
                                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                       }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void OrderingModeDecl() throws ParseException {
 /*@bgen(jjtree) OrderingModeDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTORDERINGMODEDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareOrdering);
                     SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREORDERING);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
      try {
                     jjtree.closeNodeScope(jjtn001,  true);
                     jjtc001 = false;
                    jjtn001.processToken(token);
      } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  true);
                     }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Ordered:
        jj_consume_token(Ordered);
                                                                                     SimpleNode jjtn002 = new SimpleNode(this, JJTORDERED);
                                                                                     boolean jjtc002 = true;
                                                                                     jjtree.openNodeScope(jjtn002);
        try {
                                                                                     jjtree.closeNodeScope(jjtn002,  true);
                                                                                     jjtc002 = false;
                                                             jjtn002.processToken(token);
        } finally {
                                                                                     if (jjtc002) {
                                                                                       jjtree.closeNodeScope(jjtn002,  true);
                                                                                     }
        }
        break;
      case Unordered:
        jj_consume_token(Unordered);
                                                                                                                                                SimpleNode jjtn003 = new SimpleNode(this, JJTUNORDERED);
                                                                                                                                                boolean jjtc003 = true;
                                                                                                                                                jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                jjtc003 = false;
                                                                                                         jjtn003.processToken(token);
        } finally {
                                                                                                                                                if (jjtc003) {
                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                }
        }
        break;
      default:
        jj_la1[14] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void EmptyOrderingDecl() throws ParseException {
 /*@bgen(jjtree) EmptyOrderingDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTEMPTYORDERINGDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareDefaultOrderingEmpty);
                                 SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREDEFAULTORDERINGEMPTY);
                                 boolean jjtc001 = true;
                                 jjtree.openNodeScope(jjtn001);
      try {
                                 jjtree.closeNodeScope(jjtn001,  true);
                                 jjtc001 = false;
                                jjtn001.processToken(token);
      } finally {
                                 if (jjtc001) {
                                   jjtree.closeNodeScope(jjtn001,  true);
                                 }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EmptyGreatest:
        jj_consume_token(EmptyGreatest);
                                                                                                                   SimpleNode jjtn002 = new SimpleNode(this, JJTEMPTYGREATEST);
                                                                                                                   boolean jjtc002 = true;
                                                                                                                   jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                   jjtc002 = false;
                                                                               jjtn002.processToken(token);
        } finally {
                                                                                                                   if (jjtc002) {
                                                                                                                     jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                   }
        }
        break;
      case EmptyLeast:
        jj_consume_token(EmptyLeast);
                                                                                                                                                                                     SimpleNode jjtn003 = new SimpleNode(this, JJTEMPTYLEAST);
                                                                                                                                                                                     boolean jjtc003 = true;
                                                                                                                                                                                     jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                     jjtc003 = false;
                                                                                                                            jjtn003.processToken(token);
        } finally {
                                                                                                                                                                                     if (jjtc003) {
                                                                                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                     }
        }
        break;
      default:
        jj_la1[15] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void InheritNamespacesDecl() throws ParseException {
 /*@bgen(jjtree) InheritNamespacesDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTINHERITNAMESPACESDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareInheritNamespaces);
                              SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREINHERITNAMESPACES);
                              boolean jjtc001 = true;
                              jjtree.openNodeScope(jjtn001);
      try {
                              jjtree.closeNodeScope(jjtn001,  true);
                              jjtc001 = false;
                             jjtn001.processToken(token);
      } finally {
                              if (jjtc001) {
                                jjtree.closeNodeScope(jjtn001,  true);
                              }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Yes:
        jj_consume_token(Yes);
                                                                                                   SimpleNode jjtn002 = new SimpleNode(this, JJTYES);
                                                                                                   boolean jjtc002 = true;
                                                                                                   jjtree.openNodeScope(jjtn002);
        try {
                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                                   jjtc002 = false;
                                                                  jjtn002.processToken(token);
        } finally {
                                                                                                   if (jjtc002) {
                                                                                                     jjtree.closeNodeScope(jjtn002,  true);
                                                                                                   }
        }
        break;
      case No:
        jj_consume_token(No);
                                                                                                                                                   SimpleNode jjtn003 = new SimpleNode(this, JJTNO);
                                                                                                                                                   boolean jjtc003 = true;
                                                                                                                                                   jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                   jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                   jjtc003 = false;
                                                                                                       jjtn003.processToken(token);
        } finally {
                                                                                                                                                   if (jjtc003) {
                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                   }
        }
        break;
      default:
        jj_la1[16] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void DefaultCollationDecl() throws ParseException {
 /*@bgen(jjtree) DefaultCollationDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDEFAULTCOLLATIONDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareCollation);
                      SimpleNode jjtn001 = new SimpleNode(this, JJTDECLARECOLLATION);
                      boolean jjtc001 = true;
                      jjtree.openNodeScope(jjtn001);
      try {
                      jjtree.closeNodeScope(jjtn001,  true);
                      jjtc001 = false;
                     jjtn001.processToken(token);
      } finally {
                      if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001,  true);
                      }
      }
      jj_consume_token(URLLiteral);
                                                                                         SimpleNode jjtn002 = new SimpleNode(this, JJTURLLITERAL);
                                                                                         boolean jjtc002 = true;
                                                                                         jjtree.openNodeScope(jjtn002);
      try {
                                                                                         jjtree.closeNodeScope(jjtn002,  true);
                                                                                         jjtc002 = false;
                                                                jjtn002.processToken(token);
      } finally {
                                                                                         if (jjtc002) {
                                                                                           jjtree.closeNodeScope(jjtn002,  true);
                                                                                         }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void BaseURIDecl() throws ParseException {
 /*@bgen(jjtree) BaseURIDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTBASEURIDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareBaseURI);
                    SimpleNode jjtn001 = new SimpleNode(this, JJTDECLAREBASEURI);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
      try {
                    jjtree.closeNodeScope(jjtn001,  true);
                    jjtc001 = false;
                   jjtn001.processToken(token);
      } finally {
                    if (jjtc001) {
                      jjtree.closeNodeScope(jjtn001,  true);
                    }
      }
      jj_consume_token(URLLiteral);
                                                                                     SimpleNode jjtn002 = new SimpleNode(this, JJTURLLITERAL);
                                                                                     boolean jjtc002 = true;
                                                                                     jjtree.openNodeScope(jjtn002);
      try {
                                                                                     jjtree.closeNodeScope(jjtn002,  true);
                                                                                     jjtc002 = false;
                                                              jjtn002.processToken(token);
      } finally {
                                                                                     if (jjtc002) {
                                                                                       jjtree.closeNodeScope(jjtn002,  true);
                                                                                     }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void SchemaImport() throws ParseException {
 /*@bgen(jjtree) SchemaImport */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSCHEMAIMPORT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(ImportSchemaToken);
                       SimpleNode jjtn001 = new SimpleNode(this, JJTIMPORTSCHEMATOKEN);
                       boolean jjtc001 = true;
                       jjtree.openNodeScope(jjtn001);
      try {
                       jjtree.closeNodeScope(jjtn001,  true);
                       jjtc001 = false;
                      jjtn001.processToken(token);
      } finally {
                       if (jjtc001) {
                         jjtree.closeNodeScope(jjtn001,  true);
                       }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Namespace:
      case DefaultElement:
        SchemaPrefix();
        break;
      default:
        jj_la1[17] = jj_gen;
        ;
      }
      jj_consume_token(URLLiteral);
                                                                                                            SimpleNode jjtn002 = new SimpleNode(this, JJTURLLITERAL);
                                                                                                            boolean jjtc002 = true;
                                                                                                            jjtree.openNodeScope(jjtn002);
      try {
                                                                                                            jjtree.closeNodeScope(jjtn002,  true);
                                                                                                            jjtc002 = false;
                                                                                  jjtn002.processToken(token);
      } finally {
                                                                                                            if (jjtc002) {
                                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                                            }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AtStringLiteral:
        jj_consume_token(AtStringLiteral);
                                                                                                                                                                               SimpleNode jjtn003 = new SimpleNode(this, JJTATSTRINGLITERAL);
                                                                                                                                                                               boolean jjtc003 = true;
                                                                                                                                                                               jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               jjtc003 = false;
                                                                                                                                   jjtn003.processToken(token);
        } finally {
                                                                                                                                                                               if (jjtc003) {
                                                                                                                                                                                 jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               }
        }
        label_5:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Comma:
            ;
            break;
          default:
            jj_la1[18] = jj_gen;
            break label_5;
          }
          jj_consume_token(Comma);
          jj_consume_token(StringLiteral);
                                                                                                                                                                                                                                                             SimpleNode jjtn004 = new SimpleNode(this, JJTSTRINGLITERAL);
                                                                                                                                                                                                                                                             boolean jjtc004 = true;
                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn004);
          try {
                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                             jjtc004 = false;
                                                                                                                                                                                          jjtn004.processToken(token);
          } finally {
                                                                                                                                                                                                                                                             if (jjtc004) {
                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                             }
          }
        }
        break;
      default:
        jj_la1[19] = 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 SchemaPrefix() throws ParseException {
 /*@bgen(jjtree) SchemaPrefix */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSCHEMAPREFIX);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Namespace:
        jj_consume_token(Namespace);
                 SimpleNode jjtn001 = new SimpleNode(this, JJTNAMESPACE);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
        try {
                 jjtree.closeNodeScope(jjtn001,  true);
                 jjtc001 = false;
                jjtn001.processToken(token);
        } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  true);
                 }
        }
        jj_consume_token(NCNameForPrefix);
                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
                                                                                  boolean jjtc002 = true;
                                                                                  jjtree.openNodeScope(jjtn002);
        try {
                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                  jjtc002 = false;
                                                                jjtn002.processToken(token);
        } finally {
                                                                                  if (jjtc002) {
                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                  }
        }
        jj_consume_token(AssignEquals);
                                                                                                                                                      SimpleNode jjtn003 = new SimpleNode(this, JJTASSIGNEQUALS);
                                                                                                                                                      boolean jjtc003 = true;
                                                                                                                                                      jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                      jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                      jjtc003 = false;
                                                                                                             jjtn003.processToken(token);
        } finally {
                                                                                                                                                      if (jjtc003) {
                                                                                                                                                        jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                      }
        }
        break;
      case DefaultElement:
        jj_consume_token(DefaultElement);
                                                                                                                                                                                                                             SimpleNode jjtn004 = new SimpleNode(this, JJTDEFAULTELEMENT);
                                                                                                                                                                                                                             boolean jjtc004 = true;
                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                             jjtc004 = false;
                                                                                                                                                                jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                             if (jjtc004) {
                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                             }
        }
        jj_consume_token(Namespace);
                                                                                                                                                                                                                                                                                             SimpleNode jjtn005 = new SimpleNode(this, JJTNAMESPACE);
                                                                                                                                                                                                                                                                                             boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn005);
        try {
                                                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                             jjtc005 = false;
                                                                                                                                                                                                          jjtn005.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                             if (jjtc005) {
                                                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                             }
        }
        break;
      default:
        jj_la1[20] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ModuleImport() throws ParseException {
 /*@bgen(jjtree) ModuleImport */
  SimpleNode jjtn000 = new SimpleNode(this, JJTMODULEIMPORT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(ImportModuleToken);
                       SimpleNode jjtn001 = new SimpleNode(this, JJTIMPORTMODULETOKEN);
                       boolean jjtc001 = true;
                       jjtree.openNodeScope(jjtn001);
      try {
                       jjtree.closeNodeScope(jjtn001,  true);
                       jjtc001 = false;
                      jjtn001.processToken(token);
      } finally {
                       if (jjtc001) {
                         jjtree.closeNodeScope(jjtn001,  true);
                       }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Namespace:
        jj_consume_token(Namespace);
                                                                                           SimpleNode jjtn002 = new SimpleNode(this, JJTNAMESPACE);
                                                                                           boolean jjtc002 = true;
                                                                                           jjtree.openNodeScope(jjtn002);
        try {
                                                                                           jjtree.closeNodeScope(jjtn002,  true);
                                                                                           jjtc002 = false;
                                                                 jjtn002.processToken(token);
        } finally {
                                                                                           if (jjtc002) {
                                                                                             jjtree.closeNodeScope(jjtn002,  true);
                                                                                           }
        }
        jj_consume_token(NCNameForPrefix);
                                                                                                                                                            SimpleNode jjtn003 = new SimpleNode(this, JJTNCNAMEFORPREFIX);
                                                                                                                                                            boolean jjtc003 = true;
                                                                                                                                                            jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                            jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                            jjtc003 = false;
                                                                                                                 jjtn003.processToken(token);
        } finally {
                                                                                                                                                            if (jjtc003) {
                                                                                                                                                              jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                            }
        }
        jj_consume_token(AssignEquals);
                                                                                                                                                                                                                                SimpleNode jjtn004 = new SimpleNode(this, JJTASSIGNEQUALS);
                                                                                                                                                                                                                                boolean jjtc004 = true;
                                                                                                                                                                                                                                jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                jjtc004 = false;
                                                                                                                                                              jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                if (jjtc004) {
                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                }
        }
        break;
      default:
        jj_la1[21] = jj_gen;
        ;
      }
      jj_consume_token(URLLiteral);
                                                                                                                                                                                                                                                                                                SimpleNode jjtn005 = new SimpleNode(this, JJTURLLITERAL);
                                                                                                                                                                                                                                                                                                boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                jjtree.openNodeScope(jjtn005);
      try {
                                                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                jjtc005 = false;
                                                                                                                                                                                                          jjtn005.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                if (jjtc005) {
                                                                                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AtStringLiteral:
        jj_consume_token(AtStringLiteral);
                                                                                                                                                                                                                                                                                                                                                                   SimpleNode jjtn006 = new SimpleNode(this, JJTATSTRINGLITERAL);
                                                                                                                                                                                                                                                                                                                                                                   boolean jjtc006 = true;
                                                                                                                                                                                                                                                                                                                                                                   jjtree.openNodeScope(jjtn006);
        try {
                                                                                                                                                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                   jjtc006 = false;
                                                                                                                                                                                                                                                           jjtn006.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                                                   if (jjtc006) {
                                                                                                                                                                                                                                                                                                                                                                     jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                   }
        }
        label_6:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Comma:
            ;
            break;
          default:
            jj_la1[22] = jj_gen;
            break label_6;
          }
          jj_consume_token(Comma);
          jj_consume_token(StringLiteral);
                                                                                                                                                                                                                                                                                                                                                                                                                                                 SimpleNode jjtn007 = new SimpleNode(this, JJTSTRINGLITERAL);
                                                                                                                                                                                                                                                                                                                                                                                                                                                 boolean jjtc007 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                 jjtree.openNodeScope(jjtn007);
          try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                 jjtc007 = false;
                                                                                                                                                                                                                                                                                                                  jjtn007.processToken(token);
          } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                 if (jjtc007) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
          }
        }
        break;
      default:
        jj_la1[23] = jj_gen;
        ;
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void VarDecl() throws ParseException {
 /*@bgen(jjtree) VarDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTVARDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DefineVariable);
                    SimpleNode jjtn001 = new SimpleNode(this, JJTDEFINEVARIABLE);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
      try {
                    jjtree.closeNodeScope(jjtn001,  true);
                    jjtc001 = false;
                   jjtn001.processToken(token);
      } finally {
                    if (jjtc001) {
                      jjtree.closeNodeScope(jjtn001,  true);
                    }
      }
      jj_consume_token(VarName);
                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTVARNAME);
                                                                                  boolean jjtc002 = true;
                                                                                  jjtree.openNodeScope(jjtn002);
      try {
                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                  jjtc002 = false;
                                                           jjtn002.processToken(token);
      } finally {
                                                                                  if (jjtc002) {
                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                  }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case As:
        TypeDeclaration();
        break;
      default:
        jj_la1[24] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ColonEquals:
        jj_consume_token(ColonEquals);
                                                                                                                                                                   SimpleNode jjtn003 = new SimpleNode(this, JJTCOLONEQUALS);
                                                                                                                                                                   boolean jjtc003 = true;
                                                                                                                                                                   jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                   jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                   jjtc003 = false;
                                                                                                                             jjtn003.processToken(token);
        } finally {
                                                                                                                                                                   if (jjtc003) {
                                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                   }
        }
        ExprSingle();
        break;
      case External:
        jj_consume_token(External);
                                                                                                                                                                                                                                               SimpleNode jjtn004 = new SimpleNode(this, JJTEXTERNAL);
                                                                                                                                                                                                                                               boolean jjtc004 = true;
                                                                                                                                                                                                                                               jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                               jjtc004 = false;
                                                                                                                                                                                      jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                               if (jjtc004) {
                                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                               }
        }
        break;
      default:
        jj_la1[25] = 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 ConstructionDecl() throws ParseException {
 /*@bgen(jjtree) ConstructionDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCONSTRUCTIONDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DeclareConstruction);
                         SimpleNode jjtn001 = new SimpleNode(this, JJTDECLARECONSTRUCTION);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
      try {
                         jjtree.closeNodeScope(jjtn001,  true);
                         jjtc001 = false;
                        jjtn001.processToken(token);
      } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001,  true);
                         }
      }
      jj_consume_token(SchemaModeForDeclareConstruction);
                                                                                                                     SimpleNode jjtn002 = new SimpleNode(this, JJTSCHEMAMODEFORDECLARECONSTRUCTION);
                                                                                                                     boolean jjtc002 = true;
                                                                                                                     jjtree.openNodeScope(jjtn002);
      try {
                                                                                                                     jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                     jjtc002 = false;
                                                                                         jjtn002.processToken(token);
      } finally {
                                                                                                                     if (jjtc002) {
                                                                                                                       jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                     }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void FunctionDecl() throws ParseException {
 /*@bgen(jjtree) FunctionDecl */
  SimpleNode jjtn000 = new SimpleNode(this, JJTFUNCTIONDECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DefineFunction);
                    SimpleNode jjtn001 = new SimpleNode(this, JJTDEFINEFUNCTION);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
      try {
                    jjtree.closeNodeScope(jjtn001,  true);
                    jjtc001 = false;
                   jjtn001.processToken(token);
      } finally {
                    if (jjtc001) {
                      jjtree.closeNodeScope(jjtn001,  true);
                    }
      }
      jj_consume_token(QNameLpar);
                                                                                    SimpleNode jjtn002 = new SimpleNode(this, JJTQNAMELPAR);
                                                                                    boolean jjtc002 = true;
                                                                                    jjtree.openNodeScope(jjtn002);
      try {
                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                    jjtc002 = false;
                                                             jjtn002.processToken(token);
      } finally {
                                                                                    if (jjtc002) {
                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                    }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case VariableIndicator:
        ParamList();
        break;
      default:
        jj_la1[26] = jj_gen;
        ;
      }
      jj_consume_token(Rpar);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case As:
        jj_consume_token(As);
                                                                                                                                                                SimpleNode jjtn003 = new SimpleNode(this, JJTAS);
                                                                                                                                                                boolean jjtc003 = true;
                                                                                                                                                                jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                jjtc003 = false;
                                                                                                                        jjtn003.processToken(token);
        } finally {
                                                                                                                                                                if (jjtc003) {
                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                }
        }
        SequenceType();
        break;
      default:
        jj_la1[27] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Lbrace:
      case LbraceExprEnclosure:
        EnclosedExpr();
        break;
      case External:
        jj_consume_token(External);
                                                                                                                                                                                                                                                       SimpleNode jjtn004 = new SimpleNode(this, JJTEXTERNAL);
                                                                                                                                                                                                                                                       boolean jjtc004 = true;
                                                                                                                                                                                                                                                       jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                       jjtc004 = false;
                                                                                                                                                                                                     jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                                       if (jjtc004) {
                                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                       }
        }
        break;
      default:
        jj_la1[28] = 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 ParamList() throws ParseException {
 /*@bgen(jjtree) ParamList */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPARAMLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Param();
      label_7:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Comma:
          ;
          break;
        default:
          jj_la1[29] = jj_gen;
          break label_7;
        }
        jj_consume_token(Comma);
        Param();
      }
    } 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 Param() throws ParseException {
 /*@bgen(jjtree) Param */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPARAM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(VariableIndicator);
      jj_consume_token(VarName);
                                 SimpleNode jjtn001 = new SimpleNode(this, JJTVARNAME);
                                 boolean jjtc001 = true;
                                 jjtree.openNodeScope(jjtn001);
      try {
                                 jjtree.closeNodeScope(jjtn001,  true);
                                 jjtc001 = false;
                                jjtn001.processToken(token);
      } finally {
                                 if (jjtc001) {
                                   jjtree.closeNodeScope(jjtn001,  true);
                                 }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case As:
        TypeDeclaration();
        break;
      default:
        jj_la1[30] = 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 EnclosedExpr() throws ParseException {
 /*@bgen(jjtree) EnclosedExpr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTENCLOSEDEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Lbrace:
        jj_consume_token(Lbrace);
             SimpleNode jjtn001 = new SimpleNode(this, JJTLBRACE);
             boolean jjtc001 = true;
             jjtree.openNodeScope(jjtn001);
        try {
             jjtree.closeNodeScope(jjtn001,  true);
             jjtc001 = false;
            jjtn001.processToken(token);
        } finally {
             if (jjtc001) {
               jjtree.closeNodeScope(jjtn001,  true);
             }
        }
        break;
      case LbraceExprEnclosure:
        jj_consume_token(LbraceExprEnclosure);
                                                                                 SimpleNode jjtn002 = new SimpleNode(this, JJTLBRACEEXPRENCLOSURE);
                                                                                 boolean jjtc002 = true;
                                                                                 jjtree.openNodeScope(jjtn002);
        try {
                                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                                                 jjtc002 = false;
                                                                  jjtn002.processToken(token);
        } finally {
                                                                                 if (jjtc002) {
                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                 }
        }
        break;
      default:
        jj_la1[31] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      Expr();
      jj_consume_token(Rbrace);
                                                                                                                                                           SimpleNode jjtn003 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                           boolean jjtc003 = true;
                                                                                                                                                           jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                           jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                           jjtc003 = false;
                                                                                                                 jjtn003.processToken(token);
      } finally {
                                                                                                                                                           if (jjtc003) {
                                                                                                                                                             jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                           }
      }
    } 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 QueryBody() throws ParseException {
 /*@bgen(jjtree) QueryBody */
  SimpleNode jjtn000 = new SimpleNode(this, JJTQUERYBODY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Expr();
    } 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 Expr() throws ParseException {
 /*@bgen(jjtree) Expr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ExprSingle();
      label_8:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Comma:
          ;
          break;
        default:
          jj_la1[32] = jj_gen;
          break label_8;
        }
        jj_consume_token(Comma);
        ExprSingle();
      }
    } 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 ExprSingle() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ForVariable:
    case LetVariable:
      FLWORExpr();
      break;
    case Some:
    case Every:
      QuantifiedExpr();
      break;
    case TypeswitchLpar:
      TypeswitchExpr();
      break;
    case IfLpar:
      IfExpr();
      break;
    case IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case StringLiteral:
    case ProcessingInstructionStart:
    case ProcessingInstructionStartForElementContent:
    case AxisChild:
    case AxisDescendant:
    case AxisParent:
    case AxisAttribute:
    case AxisSelf:
    case AxisDescendantOrSelf:
    case AxisAncestor:
    case AxisFollowingSibling:
    case AxisPrecedingSibling:
    case AxisFollowing:
    case AxisPreceding:
    case AxisAncestorOrSelf:
    case VariableIndicator:
    case ElementType:
    case AttributeType:
    case SchemaElementType:
    case SchemaAttributeType:
    case OrderedOpen:
    case UnorderedOpen:
    case ElementQNameLbrace:
    case AttributeQNameLbrace:
    case PINCNameLbrace:
    case PILbrace:
    case CommentLbrace:
    case ElementLbrace:
    case AttributeLbrace:
    case TextLbrace:
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case Root:
    case RootDescendants:
    case UnaryMinus:
    case UnaryPlus:
    case Lpar:
    case At:
    case ValidateLbrace:
    case ValidateSchemaMode:
    case DocumentLpar:
    case DocumentLparForKindTest:
    case DocumentLbrace:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case ElementTypeForKindTest:
    case ElementTypeForDocumentTest:
    case AttributeTypeForKindTest:
    case SchemaElementTypeForKindTest:
    case SchemaElementTypeForDocumentTest:
    case SchemaAttributeTypeForKindTest:
    case ProcessingInstructionLparForKindTest:
    case TextLparForKindTest:
    case CommentLparForKindTest:
    case NodeLparForKindTest:
    case Dot:
    case DotDot:
    case QNameLpar:
    case StartTagOpen:
    case StartTagOpenRoot:
    case XmlCommentStart:
    case XmlCommentStartForElementContent:
    case QName:
      OrExpr();
      break;
    default:
      jj_la1[33] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void FLWORExpr() throws ParseException {
 /*@bgen(jjtree) FLWORExpr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTFLWOREXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_9:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ForVariable:
          ForClause();
          break;
        case LetVariable:
          LetClause();
          break;
        default:
          jj_la1[34] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ForVariable:
        case LetVariable:
          ;
          break;
        default:
          jj_la1[35] = jj_gen;
          break label_9;
        }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Where:
        WhereClause();
        break;
      default:
        jj_la1[36] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OrderBy:
      case OrderByStable:
        OrderByClause();
        break;
      default:
        jj_la1[37] = jj_gen;
        ;
      }
      jj_consume_token(Return);
      ExprSingle();
    } 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 ForClause() throws ParseException {
    jj_consume_token(ForVariable);
    jj_consume_token(VarName);
                           SimpleNode jjtn001 = new SimpleNode(this, JJTVARNAME);
                           boolean jjtc001 = true;
                           jjtree.openNodeScope(jjtn001);
    try {
                           jjtree.closeNodeScope(jjtn001,  true);
                           jjtc001 = false;
                          jjtn001.processToken(token);
    } finally {
                           if (jjtc001) {
                             jjtree.closeNodeScope(jjtn001,  true);
                           }
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case As:
      TypeDeclaration();
      break;
    default:
      jj_la1[38] = jj_gen;
      ;
    }
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AtWord:
      PositionalVar();
      break;
    default:
      jj_la1[39] = jj_gen;
      ;
    }
    jj_consume_token(In);
                                                                                                                   SimpleNode jjtn002 = new SimpleNode(this, JJTIN);
                                                                                                                   boolean jjtc002 = true;
                                                                                                                   jjtree.openNodeScope(jjtn002);
    try {
                                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                   jjtc002 = false;
                                                                                                   jjtn002.processToken(token);
    } finally {
                                                                                                                   if (jjtc002) {
                                                                                                                     jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                   }
    }
    ExprSingle();
    label_10:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Comma:
        ;
        break;
      default:
        jj_la1[40] = jj_gen;
        break label_10;
      }
      jj_consume_token(Comma);
      jj_consume_token(VariableIndicator);
      jj_consume_token(VarName);
                                                                                                                                                                                                               SimpleNode jjtn003 = new SimpleNode(this, JJTVARNAME);
                                                                                                                                                                                                               boolean jjtc003 = true;
                                                                                                                                                                                                               jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                               jjtc003 = false;
                                                                                                                                                                                     jjtn003.processToken(token);
      } finally {
                                                                                                                                                                                                               if (jjtc003) {
                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                               }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case As:
        TypeDeclaration();
        break;
      default:
        jj_la1[41] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AtWord:
        PositionalVar();
        break;
      default:
        jj_la1[42] = jj_gen;
        ;
      }
      jj_consume_token(In);
                                                                                                                                                                                                                                                                                                       SimpleNode jjtn004 = new SimpleNode(this, JJTIN);
                                                                                                                                                                                                                                                                                                       boolean jjtc004 = true;
                                                                                                                                                                                                                                                                                                       jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                                                       jjtc004 = false;
                                                                                                                                                                                                                                                              jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                       if (jjtc004) {
                                                                                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                                                       }
      }
      ExprSingle();
    }
  }

  final public void PositionalVar() throws ParseException {
 /*@bgen(jjtree) PositionalVar */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPOSITIONALVAR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(AtWord);
            SimpleNode jjtn001 = new SimpleNode(this, JJTATWORD);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
      try {
            jjtree.closeNodeScope(jjtn001,  true);
            jjtc001 = false;
           jjtn001.processToken(token);
      } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001,  true);
            }
      }
      jj_consume_token(VariableIndicator);
      jj_consume_token(VarName);
                                                                                      SimpleNode jjtn002 = new SimpleNode(this, JJTVARNAME);
                                                                                      boolean jjtc002 = true;
                                                                                      jjtree.openNodeScope(jjtn002);
      try {
                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                      jjtc002 = false;
                                                                       jjtn002.processToken(token);
      } finally {
                                                                                      if (jjtc002) {
                                                                                        jjtree.closeNodeScope(jjtn002,  true);
                                                                                      }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void LetClause() throws ParseException {
 /*@bgen(jjtree) LetClause */
  SimpleNode jjtn000 = new SimpleNode(this, JJTLETCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(LetVariable);
                 SimpleNode jjtn001 = new SimpleNode(this, JJTLETVARIABLE);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
      try {
                 jjtree.closeNodeScope(jjtn001,  true);
                 jjtc001 = false;
                jjtn001.processToken(token);
      } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  true);
                 }
      }
      jj_consume_token(VarName);
                                                                            SimpleNode jjtn002 = new SimpleNode(this, JJTVARNAME);
                                                                            boolean jjtc002 = true;
                                                                            jjtree.openNodeScope(jjtn002);
      try {
                                                                            jjtree.closeNodeScope(jjtn002,  true);
                                                                            jjtc002 = false;
                                                        jjtn002.processToken(token);
      } finally {
                                                                            if (jjtc002) {
                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                            }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case As:
        TypeDeclaration();
        break;
      default:
        jj_la1[43] = jj_gen;
        ;
      }
      jj_consume_token(ColonEquals);
                                                                                                                                                           SimpleNode jjtn003 = new SimpleNode(this, JJTCOLONEQUALS);
                                                                                                                                                           boolean jjtc003 = true;
                                                                                                                                                           jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                           jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                           jjtc003 = false;
                                                                                                                        jjtn003.processToken(token);
      } finally {
                                                                                                                                                           if (jjtc003) {
                                                                                                                                                             jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                           }
      }
      ExprSingle();
      label_11:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Comma:
          ;
          break;
        default:
          jj_la1[44] = jj_gen;
          break label_11;
        }
        jj_consume_token(Comma);
        jj_consume_token(VariableIndicator);
        jj_consume_token(VarName);
                                                                                                                                                                                                                                                                SimpleNode jjtn004 = new SimpleNode(this, JJTVARNAME);
                                                                                                                                                                                                                                                                boolean jjtc004 = true;
                                                                                                                                                                                                                                                                jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                jjtc004 = false;
                                                                                                                                                                                                          jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                if (jjtc004) {
                                                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                }
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case As:
          TypeDeclaration();
          break;
        default:
          jj_la1[45] = jj_gen;
          ;
        }
        jj_consume_token(ColonEquals);
                                                                                                                                                                                                                                                                                                                                               SimpleNode jjtn005 = new SimpleNode(this, JJTCOLONEQUALS);
                                                                                                                                                                                                                                                                                                                                               boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                                                               jjtree.openNodeScope(jjtn005);
        try {
                                                                                                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                                               jjtc005 = false;
                                                                                                                                                                                                                                                                          jjtn005.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                               if (jjtc005) {
                                                                                                                                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                                               }
        }
        ExprSingle();
      }
    } 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 WhereClause() throws ParseException {
 /*@bgen(jjtree) WhereClause */
  SimpleNode jjtn000 = new SimpleNode(this, JJTWHERECLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(Where);
           SimpleNode jjtn001 = new SimpleNode(this, JJTWHERE);
           boolean jjtc001 = true;
           jjtree.openNodeScope(jjtn001);
      try {
           jjtree.closeNodeScope(jjtn001,  true);
           jjtc001 = false;
          jjtn001.processToken(token);
      } finally {
           if (jjtc001) {
             jjtree.closeNodeScope(jjtn001,  true);
           }
      }
      ExprSingle();
    } 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 OrderByClause() throws ParseException {
 /*@bgen(jjtree) OrderByClause */
  SimpleNode jjtn000 = new SimpleNode(this, JJTORDERBYCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OrderBy:
        jj_consume_token(OrderBy);
              SimpleNode jjtn001 = new SimpleNode(this, JJTORDERBY);
              boolean jjtc001 = true;
              jjtree.openNodeScope(jjtn001);
        try {
              jjtree.closeNodeScope(jjtn001,  true);
              jjtc001 = false;
             jjtn001.processToken(token);
        } finally {
              if (jjtc001) {
                jjtree.closeNodeScope(jjtn001,  true);
              }
        }
        break;
      case OrderByStable:
        jj_consume_token(OrderByStable);
                                                                             SimpleNode jjtn002 = new SimpleNode(this, JJTORDERBYSTABLE);
                                                                             boolean jjtc002 = true;
                                                                             jjtree.openNodeScope(jjtn002);
        try {
                                                                             jjtree.closeNodeScope(jjtn002,  true);
                                                                             jjtc002 = false;
                                                             jjtn002.processToken(token);
        } finally {
                                                                             if (jjtc002) {
                                                                               jjtree.closeNodeScope(jjtn002,  true);
                                                                             }
        }
        break;
      default:
        jj_la1[46] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      OrderSpecList();
    } 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 OrderSpecList() throws ParseException {
 /*@bgen(jjtree) OrderSpecList */
  SimpleNode jjtn000 = new SimpleNode(this, JJTORDERSPECLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      OrderSpec();
      label_12:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Comma:
          ;
          break;
        default:
          jj_la1[47] = jj_gen;
          break label_12;
        }
        jj_consume_token(Comma);
        OrderSpec();
      }
    } 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 OrderSpec() throws ParseException {
 /*@bgen(jjtree) OrderSpec */
  SimpleNode jjtn000 = new SimpleNode(this, JJTORDERSPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ExprSingle();
      OrderModifier();
    } 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 OrderModifier() throws ParseException {
 /*@bgen(jjtree) OrderModifier */
  SimpleNode jjtn000 = new SimpleNode(this, JJTORDERMODIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Ascending:
      case Descending:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Ascending:
          jj_consume_token(Ascending);
                 SimpleNode jjtn001 = new SimpleNode(this, JJTASCENDING);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
          try {
                 jjtree.closeNodeScope(jjtn001,  true);
                 jjtc001 = false;
                jjtn001.processToken(token);
          } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  true);
                 }
          }
          break;
        case Descending:
          jj_consume_token(Descending);
                                                                               SimpleNode jjtn002 = new SimpleNode(this, JJTDESCENDING);
                                                                               boolean jjtc002 = true;
                                                                               jjtree.openNodeScope(jjtn002);
          try {
                                                                               jjtree.closeNodeScope(jjtn002,  true);
                                                                               jjtc002 = false;
                                                             jjtn002.processToken(token);
          } finally {
                                                                               if (jjtc002) {
                                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                                               }
          }
          break;
        default:
          jj_la1[48] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[49] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EmptyGreatest:
      case EmptyLeast:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case EmptyGreatest:
          jj_consume_token(EmptyGreatest);
                                                                                                                                                   SimpleNode jjtn003 = new SimpleNode(this, JJTEMPTYGREATEST);
                                                                                                                                                   boolean jjtc003 = true;
                                                                                                                                                   jjtree.openNodeScope(jjtn003);
          try {
                                                                                                                                                   jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                   jjtc003 = false;
                                                                                                               jjtn003.processToken(token);
          } finally {
                                                                                                                                                   if (jjtc003) {
                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                   }
          }
          break;
        case EmptyLeast:
          jj_consume_token(EmptyLeast);
                                                                                                                                                                                                                     SimpleNode jjtn004 = new SimpleNode(this, JJTEMPTYLEAST);
                                                                                                                                                                                                                     boolean jjtc004 = true;
                                                                                                                                                                                                                     jjtree.openNodeScope(jjtn004);
          try {
                                                                                                                                                                                                                     jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                     jjtc004 = false;
                                                                                                                                                            jjtn004.processToken(token);
          } finally {
                                                                                                                                                                                                                     if (jjtc004) {
                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                     }
          }
          break;
        default:
          jj_la1[50] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[51] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Collation:
        jj_consume_token(Collation);
                                                                                                                                                                                                                                                                                    SimpleNode jjtn005 = new SimpleNode(this, JJTCOLLATION);
                                                                                                                                                                                                                                                                                    boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                    jjtree.openNodeScope(jjtn005);
        try {
                                                                                                                                                                                                                                                                                    jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                    jjtc005 = false;
                                                                                                                                                                                                         jjtn005.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                    if (jjtc005) {
                                                                                                                                                                                                                                                                                      jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                    }
        }
        jj_consume_token(StringLiteral);
                                                                                                                                                                                                                                                                                                                                                   SimpleNode jjtn006 = new SimpleNode(this, JJTSTRINGLITERAL);
                                                                                                                                                                                                                                                                                                                                                   boolean jjtc006 = true;
                                                                                                                                                                                                                                                                                                                                                   jjtree.openNodeScope(jjtn006);
        try {
                                                                                                                                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                   jjtc006 = false;
                                                                                                                                                                                                                                                       jjtn006.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                                   if (jjtc006) {
                                                                                                                                                                                                                                                                                                                                                     jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                   }
        }
        break;
      default:
        jj_la1[52] = jj_gen;
        ;
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void QuantifiedExpr() throws ParseException {
 /*@bgen(jjtree) QuantifiedExpr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTQUANTIFIEDEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Some:
        jj_consume_token(Some);
           SimpleNode jjtn001 = new SimpleNode(this, JJTSOME);
           boolean jjtc001 = true;
           jjtree.openNodeScope(jjtn001);
        try {
           jjtree.closeNodeScope(jjtn001,  true);
           jjtc001 = false;
          jjtn001.processToken(token);
        } finally {
           if (jjtc001) {
             jjtree.closeNodeScope(jjtn001,  true);
           }
        }
        break;
      case Every:
        jj_consume_token(Every);
                                                               SimpleNode jjtn002 = new SimpleNode(this, JJTEVERY);
                                                               boolean jjtc002 = true;
                                                               jjtree.openNodeScope(jjtn002);
        try {
                                                               jjtree.closeNodeScope(jjtn002,  true);
                                                               jjtc002 = false;
                                                  jjtn002.processToken(token);
        } finally {
                                                               if (jjtc002) {
                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                               }
        }
        break;
      default:
        jj_la1[53] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(VarName);
                                                                                                                     SimpleNode jjtn003 = new SimpleNode(this, JJTVARNAME);
                                                                                                                     boolean jjtc003 = true;
                                                                                                                     jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                     jjtc003 = false;
                                                                                           jjtn003.processToken(token);
      } finally {
                                                                                                                     if (jjtc003) {
                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                     }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case As:
        TypeDeclaration();
        break;
      default:
        jj_la1[54] = jj_gen;
        ;
      }
      jj_consume_token(In);
                                                                                                                                                                                           SimpleNode jjtn004 = new SimpleNode(this, JJTIN);
                                                                                                                                                                                           boolean jjtc004 = true;
                                                                                                                                                                                           jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                           jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                           jjtc004 = false;
                                                                                                                                                  jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                           if (jjtc004) {
                                                                                                                                                                                             jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                           }
      }
      ExprSingle();
      label_13:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Comma:
          ;
          break;
        default:
          jj_la1[55] = jj_gen;
          break label_13;
        }
        jj_consume_token(Comma);
        jj_consume_token(VariableIndicator);
        jj_consume_token(VarName);
                                                                                                                                                                                                                                                                                       SimpleNode jjtn005 = new SimpleNode(this, JJTVARNAME);
                                                                                                                                                                                                                                                                                       boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                       jjtree.openNodeScope(jjtn005);
        try {
                                                                                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                       jjtc005 = false;
                                                                                                                                                                                                                                    jjtn005.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                       if (jjtc005) {
                                                                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                       }
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case As:
          TypeDeclaration();
          break;
        default:
          jj_la1[56] = jj_gen;
          ;
        }
        jj_consume_token(In);
                                                                                                                                                                                                                                                                                                                                                             SimpleNode jjtn006 = new SimpleNode(this, JJTIN);
                                                                                                                                                                                                                                                                                                                                                             boolean jjtc006 = true;
                                                                                                                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn006);
        try {
                                                                                                                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                             jjtc006 = false;
                                                                                                                                                                                                                                                                                           jjtn006.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                                             if (jjtc006) {
                                                                                                                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                             }
        }
        ExprSingle();
      }
      jj_consume_token(Satisfies);
                                                                                                                                                                                                                                                                                                                                                                                                                                SimpleNode jjtn007 = new SimpleNode(this, JJTSATISFIES);
                                                                                                                                                                                                                                                                                                                                                                                                                                boolean jjtc007 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                jjtree.openNodeScope(jjtn007);
      try {
                                                                                                                                                                                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                jjtc007 = false;
                                                                                                                                                                                                                                                                                                                                                    jjtn007.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                if (jjtc007) {
                                                                                                                                                                                                                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                }
      }
      ExprSingle();
    } 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 TypeswitchExpr() throws ParseException {
 /*@bgen(jjtree) TypeswitchExpr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTTYPESWITCHEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(TypeswitchLpar);
      Expr();
      jj_consume_token(Rpar);
      label_14:
      while (true) {
        CaseClause();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Case:
          ;
          break;
        default:
          jj_la1[57] = jj_gen;
          break label_14;
        }
      }
      jj_consume_token(Default);
                                                             SimpleNode jjtn001 = new SimpleNode(this, JJTDEFAULT);
                                                             boolean jjtc001 = true;
                                                             jjtree.openNodeScope(jjtn001);
      try {
                                                             jjtree.closeNodeScope(jjtn001,  true);
                                                             jjtc001 = false;
                                                            jjtn001.processToken(token);
      } finally {
                                                             if (jjtc001) {
                                                               jjtree.closeNodeScope(jjtn001,  true);
                                                             }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case VariableIndicator:
        jj_consume_token(VariableIndicator);
        jj_consume_token(VarName);
                                                                                                                                         SimpleNode jjtn002 = new SimpleNode(this, JJTVARNAME);
                                                                                                                                         boolean jjtc002 = true;
                                                                                                                                         jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                                         jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                         jjtc002 = false;
                                                                                                                         jjtn002.processToken(token);
        } finally {
                                                                                                                                         if (jjtc002) {
                                                                                                                                           jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                         }
        }
        break;
      default:
        jj_la1[58] = jj_gen;
        ;
      }
      jj_consume_token(Return);
      ExprSingle();
    } 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 CaseClause() throws ParseException {
 /*@bgen(jjtree) CaseClause */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCASECLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(Case);
          SimpleNode jjtn001 = new SimpleNode(this, JJTCASE);
          boolean jjtc001 = true;
          jjtree.openNodeScope(jjtn001);
      try {
          jjtree.closeNodeScope(jjtn001,  true);
          jjtc001 = false;
         jjtn001.processToken(token);
      } finally {
          if (jjtc001) {
            jjtree.closeNodeScope(jjtn001,  true);
          }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case VariableIndicator:
        jj_consume_token(VariableIndicator);
        jj_consume_token(VarName);
                                                                                   SimpleNode jjtn002 = new SimpleNode(this, JJTVARNAME);
                                                                                   boolean jjtc002 = true;
                                                                                   jjtree.openNodeScope(jjtn002);
        try {
                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                   jjtc002 = false;
                                                                      jjtn002.processToken(token);
        } finally {
                                                                                   if (jjtc002) {
                                                                                     jjtree.closeNodeScope(jjtn002,  true);
                                                                                   }
        }
        jj_consume_token(As);
                                                                                                                                     SimpleNode jjtn003 = new SimpleNode(this, JJTAS);
                                                                                                                                     boolean jjtc003 = true;
                                                                                                                                     jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                     jjtc003 = false;
                                                                                                         jjtn003.processToken(token);
        } finally {
                                                                                                                                     if (jjtc003) {
                                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                     }
        }
        break;
      default:
        jj_la1[59] = jj_gen;
        ;
      }
      SequenceType();
      jj_consume_token(Return);
      ExprSingle();
    } 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 IfExpr() throws ParseException {
 /*@bgen(jjtree) IfExpr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTIFEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(IfLpar);
      Expr();
      jj_consume_token(Rpar);
      jj_consume_token(Then);
      ExprSingle();
      jj_consume_token(Else);
      ExprSingle();
    } 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 OperatorExpr() throws ParseException {
    OrExpr();
  }

  final public void OrExpr() throws ParseException {
 /*@bgen(jjtree) #OrExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTOREXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      AndExpr();
      label_15:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Or:
          ;
          break;
        default:
          jj_la1[60] = jj_gen;
          break label_15;
        }
        jj_consume_token(Or);
          binaryTokenStack.push(token);
        AndExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTOREXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
      }
    } 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void AndExpr() throws ParseException {
 /*@bgen(jjtree) #AndExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTANDEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ComparisonExpr();
      label_16:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case And:
          ;
          break;
        default:
          jj_la1[61] = jj_gen;
          break label_16;
        }
        jj_consume_token(And);
          binaryTokenStack.push(token);
        ComparisonExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTANDEXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
      }
    } 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void ComparisonExpr() throws ParseException {
 /*@bgen(jjtree) #ComparisonExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPARISONEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      RangeExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Equals:
      case Is:
      case NotEquals:
      case LtEquals:
      case LtLt:
      case GtEquals:
      case GtGt:
      case FortranEq:
      case FortranNe:
      case FortranGt:
      case FortranGe:
      case FortranLt:
      case FortranLe:
      case Lt:
      case Gt:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case FortranEq:
        case FortranNe:
        case FortranGt:
        case FortranGe:
        case FortranLt:
        case FortranLe:
          ValueComp();
          break;
        case Equals:
        case NotEquals:
        case LtEquals:
        case GtEquals:
        case Lt:
        case Gt:
          GeneralComp();
          break;
        case Is:
        case LtLt:
        case GtGt:
          NodeComp();
          break;
        default:
          jj_la1[62] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        RangeExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTCOMPARISONEXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
        break;
      default:
        jj_la1[63] = 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void RangeExpr() throws ParseException {
 /*@bgen(jjtree) #RangeExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTRANGEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      AdditiveExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case To:
        jj_consume_token(To);
          binaryTokenStack.push(token);
        AdditiveExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTRANGEEXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
        break;
      default:
        jj_la1[64] = 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void AdditiveExpr() throws ParseException {
 /*@bgen(jjtree) #AdditiveExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTADDITIVEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      MultiplicativeExpr();
      label_17:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Minus:
        case Plus:
          ;
          break;
        default:
          jj_la1[65] = jj_gen;
          break label_17;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Plus:
          jj_consume_token(Plus);
          binaryTokenStack.push(token);
          break;
        case Minus:
          jj_consume_token(Minus);
          binaryTokenStack.push(token);
          break;
        default:
          jj_la1[66] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        MultiplicativeExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTADDITIVEEXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
      }
    } 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void MultiplicativeExpr() throws ParseException {
 /*@bgen(jjtree) #MultiplicativeExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTMULTIPLICATIVEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      UnionExpr();
      label_18:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Div:
        case Idiv:
        case Mod:
        case Multiply:
          ;
          break;
        default:
          jj_la1[67] = jj_gen;
          break label_18;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Multiply:
          jj_consume_token(Multiply);
          binaryTokenStack.push(token);
          break;
        case Div:
          jj_consume_token(Div);
          binaryTokenStack.push(token);
          break;
        case Idiv:
          jj_consume_token(Idiv);
          binaryTokenStack.push(token);
          break;
        case Mod:
          jj_consume_token(Mod);
          binaryTokenStack.push(token);
          break;
        default:
          jj_la1[68] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        UnionExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTMULTIPLICATIVEEXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
      }
    } 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void UnionExpr() throws ParseException {
 /*@bgen(jjtree) #UnionExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTUNIONEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      IntersectExceptExpr();
      label_19:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Union:
        case Vbar:
          ;
          break;
        default:
          jj_la1[69] = jj_gen;
          break label_19;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Union:
          jj_consume_token(Union);
          binaryTokenStack.push(token);
          break;
        case Vbar:
          jj_consume_token(Vbar);
          binaryTokenStack.push(token);
          break;
        default:
          jj_la1[70] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        IntersectExceptExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTUNIONEXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
      }
    } 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void IntersectExceptExpr() throws ParseException {
 /*@bgen(jjtree) #IntersectExceptExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTINTERSECTEXCEPTEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      InstanceofExpr();
      label_20:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Intersect:
        case Except:
          ;
          break;
        default:
          jj_la1[71] = jj_gen;
          break label_20;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Intersect:
          jj_consume_token(Intersect);
          binaryTokenStack.push(token);
          break;
        case Except:
          jj_consume_token(Except);
          binaryTokenStack.push(token);
          break;
        default:
          jj_la1[72] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        InstanceofExpr();
                  SimpleNode jjtn001 = new SimpleNode(this, JJTINTERSECTEXCEPTEXPR);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  2);
                  jjtc001 = false;
         try
         {
                       jjtn001.processToken((Token)binaryTokenStack.pop());
         }
         catch(java.util.EmptyStackException e)
         {
           token_source.printLinePos();
           e.printStackTrace();
           {if (true) throw e;}
         }
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  2);
                  }
        }
      }
    } 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void InstanceofExpr() throws ParseException {
 /*@bgen(jjtree) #InstanceofExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTINSTANCEOFEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      TreatExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Instanceof:
        jj_consume_token(Instanceof);
        SequenceType();
        break;
      default:
        jj_la1[73] = 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void TreatExpr() throws ParseException {
 /*@bgen(jjtree) #TreatExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTTREATEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      CastableExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TreatAs:
        jj_consume_token(TreatAs);
        SequenceType();
        break;
      default:
        jj_la1[74] = 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void CastableExpr() throws ParseException {
 /*@bgen(jjtree) #CastableExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCASTABLEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      CastExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Castable:
        jj_consume_token(Castable);
        SingleType();
        break;
      default:
        jj_la1[75] = 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void CastExpr() throws ParseException {
 /*@bgen(jjtree) #CastExpr(> 1) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCASTEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      UnaryExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CastAs:
        jj_consume_token(CastAs);
                         SimpleNode jjtn001 = new SimpleNode(this, JJTCASTAS);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
        try {
                         jjtree.closeNodeScope(jjtn001,  true);
                         jjtc001 = false;
                        jjtn001.processToken(token);
        } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001,  true);
                         }
        }
        SingleType();
        break;
      default:
        jj_la1[76] = 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, jjtree.nodeArity() > 1);
    }
    }
  }

  final public void UnaryExpr() throws ParseException {
 /*@bgen(jjtree) #UnaryExpr( keepUnary) */
 SimpleNode jjtn000 = new SimpleNode(this, JJTUNARYEXPR);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);boolean keepUnary=false;
    try {
      label_21:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case UnaryMinus:
        case UnaryPlus:
          ;
          break;
        default:
          jj_la1[77] = jj_gen;
          break label_21;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case UnaryMinus:
          jj_consume_token(UnaryMinus);
                 SimpleNode jjtn001 = new SimpleNode(this, JJTUNARYMINUS);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
          try {
                 jjtree.closeNodeScope(jjtn001,  true);
                 jjtc001 = false;
                keepUnary=true;jjtn001.processToken(token);
          } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  true);
                 }
          }
          break;
        case UnaryPlus:
          jj_consume_token(UnaryPlus);
                                                                                              SimpleNode jjtn002 = new SimpleNode(this, JJTUNARYPLUS);
                                                                                              boolean jjtc002 = true;
                                                                                              jjtree.openNodeScope(jjtn002);
          try {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                              jjtc002 = false;
                                                                           keepUnary=true;jjtn002.processToken(token);
          } finally {
                                                                                              if (jjtc002) {
                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                              }
          }
          break;
        default:
          jj_la1[78] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      ValueExpr();
    } 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,  keepUnary);
    }
    }
  }

  final public void ValueExpr() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ValidateLbrace:
    case ValidateSchemaMode:
      ValidateExpr();
      break;
    case IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case StringLiteral:
    case ProcessingInstructionStart:
    case ProcessingInstructionStartForElementContent:
    case AxisChild:
    case AxisDescendant:
    case AxisParent:
    case AxisAttribute:
    case AxisSelf:
    case AxisDescendantOrSelf:
    case AxisAncestor:
    case AxisFollowingSibling:
    case AxisPrecedingSibling:
    case AxisFollowing:
    case AxisPreceding:
    case AxisAncestorOrSelf:
    case VariableIndicator:
    case ElementType:
    case AttributeType:
    case SchemaElementType:
    case SchemaAttributeType:
    case OrderedOpen:
    case UnorderedOpen:
    case ElementQNameLbrace:
    case AttributeQNameLbrace:
    case PINCNameLbrace:
    case PILbrace:
    case CommentLbrace:
    case ElementLbrace:
    case AttributeLbrace:
    case TextLbrace:
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case Root:
    case RootDescendants:
    case Lpar:
    case At:
    case DocumentLpar:
    case DocumentLparForKindTest:
    case DocumentLbrace:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case ElementTypeForKindTest:
    case ElementTypeForDocumentTest:
    case AttributeTypeForKindTest:
    case SchemaElementTypeForKindTest:
    case SchemaElementTypeForDocumentTest:
    case SchemaAttributeTypeForKindTest:
    case ProcessingInstructionLparForKindTest:
    case TextLparForKindTest:
    case CommentLparForKindTest:
    case NodeLparForKindTest:
    case Dot:
    case DotDot:
    case QNameLpar:
    case StartTagOpen:
    case StartTagOpenRoot:
    case XmlCommentStart:
    case XmlCommentStartForElementContent:
    case QName:
      PathExpr();
      break;
    default:
      jj_la1[79] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void GeneralComp() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Equals:
      jj_consume_token(Equals);
          binaryTokenStack.push(token);
      break;
    case NotEquals:
      jj_consume_token(NotEquals);
          binaryTokenStack.push(token);
      break;
    case Lt:
      jj_consume_token(Lt);
          binaryTokenStack.push(token);
      break;
    case LtEquals:
      jj_consume_token(LtEquals);
          binaryTokenStack.push(token);
      break;
    case Gt:
      jj_consume_token(Gt);
          binaryTokenStack.push(token);
      break;
    case GtEquals:
      jj_consume_token(GtEquals);
          binaryTokenStack.push(token);
      break;
    default:
      jj_la1[80] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ValueComp() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case FortranEq:
      jj_consume_token(FortranEq);
          binaryTokenStack.push(token);
      break;
    case FortranNe:
      jj_consume_token(FortranNe);
          binaryTokenStack.push(token);
      break;
    case FortranLt:
      jj_consume_token(FortranLt);
          binaryTokenStack.push(token);
      break;
    case FortranLe:
      jj_consume_token(FortranLe);
          binaryTokenStack.push(token);
      break;
    case FortranGt:
      jj_consume_token(FortranGt);
          binaryTokenStack.push(token);
      break;
    case FortranGe:
      jj_consume_token(FortranGe);
          binaryTokenStack.push(token);
      break;
    default:
      jj_la1[81] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void NodeComp() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Is:
      jj_consume_token(Is);
          binaryTokenStack.push(token);
      break;
    case LtLt:
      jj_consume_token(LtLt);
          binaryTokenStack.push(token);
      break;
    case GtGt:
      jj_consume_token(GtGt);
          binaryTokenStack.push(token);
      break;
    default:
      jj_la1[82] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ValidateExpr() throws ParseException {
 /*@bgen(jjtree) ValidateExpr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTVALIDATEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ValidateLbrace:
        jj_consume_token(ValidateLbrace);
                     SimpleNode jjtn001 = new SimpleNode(this, JJTVALIDATELBRACE);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
        try {
                     jjtree.closeNodeScope(jjtn001,  true);
                     jjtc001 = false;
                    jjtn001.processToken(token);
        } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  true);
                     }
        }
        break;
      case ValidateSchemaMode:
        jj_consume_token(ValidateSchemaMode);
                                                                                                 SimpleNode jjtn002 = new SimpleNode(this, JJTVALIDATESCHEMAMODE);
                                                                                                 boolean jjtc002 = true;
                                                                                                 jjtree.openNodeScope(jjtn002);
        try {
                                                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                                                                 jjtc002 = false;
                                                                          jjtn002.processToken(token);
        } finally {
                                                                                                 if (jjtc002) {
                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                                 }
        }
        jj_consume_token(LbraceExprEnclosure);
                                                                                                                                                                               SimpleNode jjtn003 = new SimpleNode(this, JJTLBRACEEXPRENCLOSURE);
                                                                                                                                                                               boolean jjtc003 = true;
                                                                                                                                                                               jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               jjtc003 = false;
                                                                                                                              jjtn003.processToken(token);
        } finally {
                                                                                                                                                                               if (jjtc003) {
                                                                                                                                                                                 jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               }
        }
        break;
      default:
        jj_la1[83] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      Expr();
      jj_consume_token(Rbrace);
                                                                                                                                                                                                                                                          SimpleNode jjtn004 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                                                                                                                          boolean jjtc004 = true;
                                                                                                                                                                                                                                                          jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                                                                                          jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                          jjtc004 = false;
                                                                                                                                                                              jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                                                                                          if (jjtc004) {
                                                                                                                                                                                                                                                            jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                          }
      }
    } 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 PathExpr() throws ParseException {
 /*@bgen(jjtree) #PathExpr(> 0) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPATHEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Root:
        jj_consume_token(Root);
            SimpleNode jjtn001 = new SimpleNode(this, JJTROOT);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
        try {
            jjtree.closeNodeScope(jjtn001,  true);
            jjtc001 = false;
           jjtn001.processToken(token);
        } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001,  true);
            }
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IntegerLiteral:
        case DecimalLiteral:
        case DoubleLiteral:
        case StringLiteral:
        case ProcessingInstructionStart:
        case ProcessingInstructionStartForElementContent:
        case AxisChild:
        case AxisDescendant:
        case AxisParent:
        case AxisAttribute:
        case AxisSelf:
        case AxisDescendantOrSelf:
        case AxisAncestor:
        case AxisFollowingSibling:
        case AxisPrecedingSibling:
        case AxisFollowing:
        case AxisPreceding:
        case AxisAncestorOrSelf:
        case VariableIndicator:
        case ElementType:
        case AttributeType:
        case SchemaElementType:
        case SchemaAttributeType:
        case OrderedOpen:
        case UnorderedOpen:
        case ElementQNameLbrace:
        case AttributeQNameLbrace:
        case PINCNameLbrace:
        case PILbrace:
        case CommentLbrace:
        case ElementLbrace:
        case AttributeLbrace:
        case TextLbrace:
        case Star:
        case NCNameColonStar:
        case StarColonNCName:
        case Lpar:
        case At:
        case DocumentLpar:
        case DocumentLparForKindTest:
        case DocumentLbrace:
        case NodeLpar:
        case CommentLpar:
        case TextLpar:
        case ProcessingInstructionLpar:
        case ElementTypeForKindTest:
        case ElementTypeForDocumentTest:
        case AttributeTypeForKindTest:
        case SchemaElementTypeForKindTest:
        case SchemaElementTypeForDocumentTest:
        case SchemaAttributeTypeForKindTest:
        case ProcessingInstructionLparForKindTest:
        case TextLparForKindTest:
        case CommentLparForKindTest:
        case NodeLparForKindTest:
        case Dot:
        case DotDot:
        case QNameLpar:
        case StartTagOpen:
        case StartTagOpenRoot:
        case XmlCommentStart:
        case XmlCommentStartForElementContent:
        case QName:
          RelativePathExpr();
          break;
        default:
          jj_la1[84] = jj_gen;
          ;
        }
        break;
      case RootDescendants:
        jj_consume_token(RootDescendants);
                                                                                                 SimpleNode jjtn002 = new SimpleNode(this, JJTROOTDESCENDANTS);
                                                                                                 boolean jjtc002 = true;
                                                                                                 jjtree.openNodeScope(jjtn002);
        try {
                                                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                                                                 jjtc002 = false;
                                                                                    jjtn002.processToken(token);
        } finally {
                                                                                                 if (jjtc002) {
                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                                 }
        }
        RelativePathExpr();
        break;
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case VariableIndicator:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case OrderedOpen:
      case UnorderedOpen:
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Lpar:
      case At:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case DocumentLbrace:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case Dot:
      case DotDot:
      case QNameLpar:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
      case QName:
        RelativePathExpr();
        break;
      default:
        jj_la1[85] = 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, jjtree.nodeArity() > 0);
    }
    }
  }

  final public void RelativePathExpr() throws ParseException {
    StepExpr();
    label_22:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Slash:
      case SlashSlash:
        ;
        break;
      default:
        jj_la1[86] = jj_gen;
        break label_22;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Slash:
        jj_consume_token(Slash);
        break;
      case SlashSlash:
        jj_consume_token(SlashSlash);
                                       SimpleNode jjtn001 = new SimpleNode(this, JJTSLASHSLASH);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
        try {
                                       jjtree.closeNodeScope(jjtn001,  true);
                                       jjtc001 = false;
                                      jjtn001.processToken(token);
        } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                       }
        }
        break;
      default:
        jj_la1[87] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      StepExpr();
    }
  }

  final public void StepExpr() throws ParseException {
 /*@bgen(jjtree) #StepExpr(> 1 || isStep) */
 SimpleNode jjtn000 = new SimpleNode(this, JJTSTEPEXPR);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);boolean savedIsStep = isStep; isStep=false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case At:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case DotDot:
      case QName:
    isStep=true;
        AxisStep();
                             jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1 || isStep);
                             jjtc000 = false;
                            isStep = savedIsStep;
        break;
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case VariableIndicator:
      case OrderedOpen:
      case UnorderedOpen:
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case Lpar:
      case DocumentLbrace:
      case Dot:
      case QNameLpar:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
        FilterExpr();
                                                                   jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1 || isStep);
                                                                   jjtc000 = false;
                                                                  isStep = savedIsStep;
        break;
      default:
        jj_la1[88] = 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, jjtree.nodeArity() > 1 || isStep);
    }
    }
  }

  final public void AxisStep() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AxisChild:
    case AxisDescendant:
    case AxisAttribute:
    case AxisSelf:
    case AxisDescendantOrSelf:
    case AxisFollowingSibling:
    case AxisFollowing:
    case ElementType:
    case AttributeType:
    case SchemaElementType:
    case SchemaAttributeType:
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case At:
    case DocumentLpar:
    case DocumentLparForKindTest:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case ElementTypeForKindTest:
    case ElementTypeForDocumentTest:
    case AttributeTypeForKindTest:
    case SchemaElementTypeForKindTest:
    case SchemaElementTypeForDocumentTest:
    case SchemaAttributeTypeForKindTest:
    case ProcessingInstructionLparForKindTest:
    case TextLparForKindTest:
    case CommentLparForKindTest:
    case NodeLparForKindTest:
    case QName:
      ForwardStep();
      break;
    case AxisParent:
    case AxisAncestor:
    case AxisPrecedingSibling:
    case AxisPreceding:
    case AxisAncestorOrSelf:
    case DotDot:
      ReverseStep();
      break;
    default:
      jj_la1[89] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    PredicateList();
  }

  final public void ForwardStep() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AxisChild:
    case AxisDescendant:
    case AxisAttribute:
    case AxisSelf:
    case AxisDescendantOrSelf:
    case AxisFollowingSibling:
    case AxisFollowing:
      ForwardAxis();
      NodeTest();
      break;
    case ElementType:
    case AttributeType:
    case SchemaElementType:
    case SchemaAttributeType:
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case At:
    case DocumentLpar:
    case DocumentLparForKindTest:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case ElementTypeForKindTest:
    case ElementTypeForDocumentTest:
    case AttributeTypeForKindTest:
    case SchemaElementTypeForKindTest:
    case SchemaElementTypeForDocumentTest:
    case SchemaAttributeTypeForKindTest:
    case ProcessingInstructionLparForKindTest:
    case TextLparForKindTest:
    case CommentLparForKindTest:
    case NodeLparForKindTest:
    case QName:
      AbbrevForwardStep();
      break;
    default:
      jj_la1[90] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ForwardAxis() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AxisChild:
      jj_consume_token(AxisChild);
                SimpleNode jjtn001 = new SimpleNode(this, JJTAXISCHILD);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
      try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
      } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
      }
      break;
    case AxisDescendant:
      jj_consume_token(AxisDescendant);
                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTAXISDESCENDANT);
                                                                                  boolean jjtc002 = true;
                                                                                  jjtree.openNodeScope(jjtn002);
      try {
                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                  jjtc002 = false;
                                                                jjtn002.processToken(token);
      } finally {
                                                                                  if (jjtc002) {
                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                  }
      }
      break;
    case AxisAttribute:
      jj_consume_token(AxisAttribute);
                                                                                                                                                        SimpleNode jjtn003 = new SimpleNode(this, JJTAXISATTRIBUTE);
                                                                                                                                                        boolean jjtc003 = true;
                                                                                                                                                        jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                        jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                        jjtc003 = false;
                                                                                                                jjtn003.processToken(token);
      } finally {
                                                                                                                                                        if (jjtc003) {
                                                                                                                                                          jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                        }
      }
      break;
    case AxisSelf:
      jj_consume_token(AxisSelf);
                                                                                                                                                                                                                        SimpleNode jjtn004 = new SimpleNode(this, JJTAXISSELF);
                                                                                                                                                                                                                        boolean jjtc004 = true;
                                                                                                                                                                                                                        jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                                                        jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                        jjtc004 = false;
                                                                                                                                                           jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                                                        if (jjtc004) {
                                                                                                                                                                                                                          jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                        }
      }
      break;
    case AxisDescendantOrSelf:
      jj_consume_token(AxisDescendantOrSelf);
                                                                                                                                                                                                                                                                                               SimpleNode jjtn005 = new SimpleNode(this, JJTAXISDESCENDANTORSELF);
                                                                                                                                                                                                                                                                                               boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                               jjtree.openNodeScope(jjtn005);
      try {
                                                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                               jjtc005 = false;
                                                                                                                                                                                                                  jjtn005.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                               if (jjtc005) {
                                                                                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                               }
      }
      break;
    case AxisFollowingSibling:
      jj_consume_token(AxisFollowingSibling);
                                                                                                                                                                                                                                                                                                                                                                                  SimpleNode jjtn006 = new SimpleNode(this, JJTAXISFOLLOWINGSIBLING);
                                                                                                                                                                                                                                                                                                                                                                                  boolean jjtc006 = true;
                                                                                                                                                                                                                                                                                                                                                                                  jjtree.openNodeScope(jjtn006);
      try {
                                                                                                                                                                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                                  jjtc006 = false;
                                                                                                                                                                                                                                                                         jjtn006.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                  if (jjtc006) {
                                                                                                                                                                                                                                                                                                                                                                                    jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                                  }
      }
      break;
    case AxisFollowing:
      jj_consume_token(AxisFollowing);
                                                                                                                                                                                                                                                                                                                                                                                                                                                              SimpleNode jjtn007 = new SimpleNode(this, JJTAXISFOLLOWING);
                                                                                                                                                                                                                                                                                                                                                                                                                                                              boolean jjtc007 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              jjtree.openNodeScope(jjtn007);
      try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                              jjtc007 = false;
                                                                                                                                                                                                                                                                                                                         jjtn007.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (jjtc007) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
      }
      break;
    default:
      jj_la1[91] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void AbbrevForwardStep() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case At:
      jj_consume_token(At);
         SimpleNode jjtn001 = new SimpleNode(this, JJTAT);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
      try {
         jjtree.closeNodeScope(jjtn001,  true);
         jjtc001 = false;
        jjtn001.processToken(token);
      } finally {
         if (jjtc001) {
           jjtree.closeNodeScope(jjtn001,  true);
         }
      }
      break;
    default:
      jj_la1[92] = jj_gen;
      ;
    }
    NodeTest();
  }

  final public void ReverseStep() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AxisParent:
    case AxisAncestor:
    case AxisPrecedingSibling:
    case AxisPreceding:
    case AxisAncestorOrSelf:
      ReverseAxis();
      NodeTest();
      break;
    case DotDot:
      AbbrevReverseStep();
      break;
    default:
      jj_la1[93] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ReverseAxis() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AxisParent:
      jj_consume_token(AxisParent);
                 SimpleNode jjtn001 = new SimpleNode(this, JJTAXISPARENT);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
      try {
                 jjtree.closeNodeScope(jjtn001,  true);
                 jjtc001 = false;
                jjtn001.processToken(token);
      } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  true);
                 }
      }
      break;
    case AxisAncestor:
      jj_consume_token(AxisAncestor);
                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTAXISANCESTOR);
                                                                                  boolean jjtc002 = true;
                                                                                  jjtree.openNodeScope(jjtn002);
      try {
                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                  jjtc002 = false;
                                                               jjtn002.processToken(token);
      } finally {
                                                                                  if (jjtc002) {
                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                  }
      }
      break;
    case AxisPrecedingSibling:
      jj_consume_token(AxisPrecedingSibling);
                                                                                                                                                             SimpleNode jjtn003 = new SimpleNode(this, JJTAXISPRECEDINGSIBLING);
                                                                                                                                                             boolean jjtc003 = true;
                                                                                                                                                             jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                             jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                             jjtc003 = false;
                                                                                                                      jjtn003.processToken(token);
      } finally {
                                                                                                                                                             if (jjtc003) {
                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                             }
      }
      break;
    case AxisPreceding:
      jj_consume_token(AxisPreceding);
                                                                                                                                                                                                                                         SimpleNode jjtn004 = new SimpleNode(this, JJTAXISPRECEDING);
                                                                                                                                                                                                                                         boolean jjtc004 = true;
                                                                                                                                                                                                                                         jjtree.openNodeScope(jjtn004);
      try {
                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                         jjtc004 = false;
                                                                                                                                                                      jjtn004.processToken(token);
      } finally {
                                                                                                                                                                                                                                         if (jjtc004) {
                                                                                                                                                                                                                                           jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                         }
      }
      break;
    case AxisAncestorOrSelf:
      jj_consume_token(AxisAncestorOrSelf);
                                                                                                                                                                                                                                                                                                                   SimpleNode jjtn005 = new SimpleNode(this, JJTAXISANCESTORORSELF);
                                                                                                                                                                                                                                                                                                                   boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                                   jjtree.openNodeScope(jjtn005);
      try {
                                                                                                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                   jjtc005 = false;
                                                                                                                                                                                                                           jjtn005.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                   if (jjtc005) {
                                                                                                                                                                                                                                                                                                                     jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                   }
      }
      break;
    default:
      jj_la1[94] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void AbbrevReverseStep() throws ParseException {
    jj_consume_token(DotDot);
            SimpleNode jjtn001 = new SimpleNode(this, JJTDOTDOT);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
    try {
            jjtree.closeNodeScope(jjtn001,  true);
            jjtc001 = false;
           jjtn001.processToken(token);
    } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001,  true);
            }
    }
  }

  final public void NodeTest() throws ParseException {
 /*@bgen(jjtree) NodeTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTNODETEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
        KindTest();
        break;
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case QName:
        NameTest();
        break;
      default:
        jj_la1[95] = 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 NameTest() throws ParseException {
 /*@bgen(jjtree) NameTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTNAMETEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QName:
        jj_consume_token(QName);
            SimpleNode jjtn001 = new SimpleNode(this, JJTQNAME);
            boolean jjtc001 = true;
            jjtree.openNodeScope(jjtn001);
        try {
            jjtree.closeNodeScope(jjtn001,  true);
            jjtc001 = false;
           jjtn001.processToken(token);
        } finally {
            if (jjtc001) {
              jjtree.closeNodeScope(jjtn001,  true);
            }
        }
        break;
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
        Wildcard();
        break;
      default:
        jj_la1[96] = 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 Wildcard() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Star:
      jj_consume_token(Star);
           SimpleNode jjtn001 = new SimpleNode(this, JJTSTAR);
           boolean jjtc001 = true;
           jjtree.openNodeScope(jjtn001);
      try {
           jjtree.closeNodeScope(jjtn001,  true);
           jjtc001 = false;
          jjtn001.processToken(token);
      } finally {
           if (jjtc001) {
             jjtree.closeNodeScope(jjtn001,  true);
           }
      }
      break;
    case NCNameColonStar:
      jj_consume_token(NCNameColonStar);
                                                                         SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMECOLONSTAR);
                                                                         boolean jjtc002 = true;
                                                                         jjtree.openNodeScope(jjtn002);
      try {
                                                                         jjtree.closeNodeScope(jjtn002,  true);
                                                                         jjtc002 = false;
                                                            jjtn002.processToken(token);
      } finally {
                                                                         if (jjtc002) {
                                                                           jjtree.closeNodeScope(jjtn002,  true);
                                                                         }
      }
      break;
    case StarColonNCName:
      jj_consume_token(StarColonNCName);
                                                                                                                                                  SimpleNode jjtn003 = new SimpleNode(this, JJTSTARCOLONNCNAME);
                                                                                                                                                  boolean jjtc003 = true;
                                                                                                                                                  jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                  jjtc003 = false;
                                                                                                              jjtn003.processToken(token);
      } finally {
                                                                                                                                                  if (jjtc003) {
                                                                                                                                                    jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                  }
      }
      break;
    default:
      jj_la1[97] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void FilterExpr() throws ParseException {
    PrimaryExpr();
    PredicateList();
  }

  final public void PredicateList() throws ParseException {
 /*@bgen(jjtree) #PredicateList(> 0) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPREDICATELIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_23:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Lbrack:
          ;
          break;
        default:
          jj_la1[98] = jj_gen;
          break label_23;
        }
        Predicate();
      }
    } 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, jjtree.nodeArity() > 0);
    }
    }
  }

  final public void Predicate() throws ParseException {
 /*@bgen(jjtree) #Predicate(> 0) */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPREDICATE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(Lbrack);
      Expr();
      jj_consume_token(Rbrack);
    } 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, jjtree.nodeArity() > 0);
    }
    }
  }

  final public void PrimaryExpr() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case StringLiteral:
      Literal();
      break;
    case VariableIndicator:
      VarRef();
      break;
    case Lpar:
      ParenthesizedExpr();
      break;
    case Dot:
                                                 isStep=true;
      ContextItemExpr();
      break;
    case QNameLpar:
      FunctionCall();
      break;
    case ProcessingInstructionStart:
    case ProcessingInstructionStartForElementContent:
    case ElementQNameLbrace:
    case AttributeQNameLbrace:
    case PINCNameLbrace:
    case PILbrace:
    case CommentLbrace:
    case ElementLbrace:
    case AttributeLbrace:
    case TextLbrace:
    case DocumentLbrace:
    case StartTagOpen:
    case StartTagOpenRoot:
    case XmlCommentStart:
    case XmlCommentStartForElementContent:
      Constructor();
      break;
    case OrderedOpen:
      OrderedExpr();
      break;
    case UnorderedOpen:
      UnorderedExpr();
      break;
    default:
      jj_la1[99] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void Literal() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
      NumericLiteral();
      break;
    case StringLiteral:
      jj_consume_token(StringLiteral);
                                       SimpleNode jjtn001 = new SimpleNode(this, JJTSTRINGLITERAL);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
      try {
                                       jjtree.closeNodeScope(jjtn001,  true);
                                       jjtc001 = false;
                                      jjtn001.processToken(token);
      } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                       }
      }
      break;
    default:
      jj_la1[100] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void NumericLiteral() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IntegerLiteral:
      jj_consume_token(IntegerLiteral);
                     SimpleNode jjtn001 = new SimpleNode(this, JJTINTEGERLITERAL);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
      try {
                     jjtree.closeNodeScope(jjtn001,  true);
                     jjtc001 = false;
                    jjtn001.processToken(token);
      } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  true);
                     }
      }
      break;
    case DecimalLiteral:
      jj_consume_token(DecimalLiteral);
                                                                                            SimpleNode jjtn002 = new SimpleNode(this, JJTDECIMALLITERAL);
                                                                                            boolean jjtc002 = true;
                                                                                            jjtree.openNodeScope(jjtn002);
      try {
                                                                                            jjtree.closeNodeScope(jjtn002,  true);
                                                                                            jjtc002 = false;
                                                                     jjtn002.processToken(token);
      } finally {
                                                                                            if (jjtc002) {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                            }
      }
      break;
    case DoubleLiteral:
      jj_consume_token(DoubleLiteral);
                                                                                                                                                                  SimpleNode jjtn003 = new SimpleNode(this, JJTDOUBLELITERAL);
                                                                                                                                                                  boolean jjtc003 = true;
                                                                                                                                                                  jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                  jjtc003 = false;
                                                                                                                     jjtn003.processToken(token);
      } finally {
                                                                                                                                                                  if (jjtc003) {
                                                                                                                                                                    jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                  }
      }
      break;
    default:
      jj_la1[101] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void VarRef() throws ParseException {
    jj_consume_token(VariableIndicator);
    jj_consume_token(VarName);
                                 SimpleNode jjtn001 = new SimpleNode(this, JJTVARNAME);
                                 boolean jjtc001 = true;
                                 jjtree.openNodeScope(jjtn001);
    try {
                                 jjtree.closeNodeScope(jjtn001,  true);
                                 jjtc001 = false;
                                jjtn001.processToken(token);
    } finally {
                                 if (jjtc001) {
                                   jjtree.closeNodeScope(jjtn001,  true);
                                 }
    }
  }

  final public void ParenthesizedExpr() throws ParseException {
    jj_consume_token(Lpar);
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case StringLiteral:
    case ProcessingInstructionStart:
    case ProcessingInstructionStartForElementContent:
    case AxisChild:
    case AxisDescendant:
    case AxisParent:
    case AxisAttribute:
    case AxisSelf:
    case AxisDescendantOrSelf:
    case AxisAncestor:
    case AxisFollowingSibling:
    case AxisPrecedingSibling:
    case AxisFollowing:
    case AxisPreceding:
    case AxisAncestorOrSelf:
    case VariableIndicator:
    case ElementType:
    case AttributeType:
    case SchemaElementType:
    case SchemaAttributeType:
    case OrderedOpen:
    case UnorderedOpen:
    case ElementQNameLbrace:
    case AttributeQNameLbrace:
    case PINCNameLbrace:
    case PILbrace:
    case CommentLbrace:
    case ElementLbrace:
    case AttributeLbrace:
    case TextLbrace:
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case Root:
    case RootDescendants:
    case UnaryMinus:
    case UnaryPlus:
    case Lpar:
    case At:
    case Some:
    case Every:
    case ForVariable:
    case LetVariable:
    case ValidateLbrace:
    case ValidateSchemaMode:
    case DocumentLpar:
    case DocumentLparForKindTest:
    case DocumentLbrace:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case ElementTypeForKindTest:
    case ElementTypeForDocumentTest:
    case AttributeTypeForKindTest:
    case SchemaElementTypeForKindTest:
    case SchemaElementTypeForDocumentTest:
    case SchemaAttributeTypeForKindTest:
    case ProcessingInstructionLparForKindTest:
    case TextLparForKindTest:
    case CommentLparForKindTest:
    case NodeLparForKindTest:
    case IfLpar:
    case TypeswitchLpar:
    case Dot:
    case DotDot:
    case QNameLpar:
    case StartTagOpen:
    case StartTagOpenRoot:
    case XmlCommentStart:
    case XmlCommentStartForElementContent:
    case QName:
      Expr();
      break;
    default:
      jj_la1[102] = jj_gen;
      ;
    }
    jj_consume_token(Rpar);
  }

  final public void ContextItemExpr() throws ParseException {
    jj_consume_token(Dot);
         SimpleNode jjtn001 = new SimpleNode(this, JJTDOT);
         boolean jjtc001 = true;
         jjtree.openNodeScope(jjtn001);
    try {
         jjtree.closeNodeScope(jjtn001,  true);
         jjtc001 = false;
        jjtn001.processToken(token);
    } finally {
         if (jjtc001) {
           jjtree.closeNodeScope(jjtn001,  true);
         }
    }
  }

  final public void OrderedExpr() throws ParseException {
    jj_consume_token(OrderedOpen);
                 SimpleNode jjtn001 = new SimpleNode(this, JJTORDEREDOPEN);
                 boolean jjtc001 = true;
                 jjtree.openNodeScope(jjtn001);
    try {
                 jjtree.closeNodeScope(jjtn001,  true);
                 jjtc001 = false;
                jjtn001.processToken(token);
    } finally {
                 if (jjtc001) {
                   jjtree.closeNodeScope(jjtn001,  true);
                 }
    }
    Expr();
    jj_consume_token(Rbrace);
                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTRBRACE);
                                                                                  boolean jjtc002 = true;
                                                                                  jjtree.openNodeScope(jjtn002);
    try {
                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                  jjtc002 = false;
                                                              jjtn002.processToken(token);
    } finally {
                                                                                  if (jjtc002) {
                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                  }
    }
  }

  final public void UnorderedExpr() throws ParseException {
    jj_consume_token(UnorderedOpen);
                   SimpleNode jjtn001 = new SimpleNode(this, JJTUNORDEREDOPEN);
                   boolean jjtc001 = true;
                   jjtree.openNodeScope(jjtn001);
    try {
                   jjtree.closeNodeScope(jjtn001,  true);
                   jjtc001 = false;
                  jjtn001.processToken(token);
    } finally {
                   if (jjtc001) {
                     jjtree.closeNodeScope(jjtn001,  true);
                   }
    }
    Expr();
    jj_consume_token(Rbrace);
                                                                                      SimpleNode jjtn002 = new SimpleNode(this, JJTRBRACE);
                                                                                      boolean jjtc002 = true;
                                                                                      jjtree.openNodeScope(jjtn002);
    try {
                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                      jjtc002 = false;
                                                                jjtn002.processToken(token);
    } finally {
                                                                                      if (jjtc002) {
                                                                                        jjtree.closeNodeScope(jjtn002,  true);
                                                                                      }
    }
  }

  final public void FunctionCall() throws ParseException {
 /*@bgen(jjtree) FunctionCall */
  SimpleNode jjtn000 = new SimpleNode(this, JJTFUNCTIONCALL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QNameLpar);
                SimpleNode jjtn001 = new SimpleNode(this, JJTQNAMELPAR);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
      try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
      } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case VariableIndicator:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case OrderedOpen:
      case UnorderedOpen:
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Root:
      case RootDescendants:
      case UnaryMinus:
      case UnaryPlus:
      case Lpar:
      case At:
      case Some:
      case Every:
      case ForVariable:
      case LetVariable:
      case ValidateLbrace:
      case ValidateSchemaMode:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case DocumentLbrace:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case IfLpar:
      case TypeswitchLpar:
      case Dot:
      case DotDot:
      case QNameLpar:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
      case QName:
        ExprSingle();
        label_24:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Comma:
            ;
            break;
          default:
            jj_la1[103] = jj_gen;
            break label_24;
          }
          jj_consume_token(Comma);
          ExprSingle();
        }
        break;
      default:
        jj_la1[104] = jj_gen;
        ;
      }
      jj_consume_token(Rpar);
    } 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 Constructor() throws ParseException {
 /*@bgen(jjtree) Constructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
        DirectConstructor();
        break;
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case DocumentLbrace:
        ComputedConstructor();
        break;
      default:
        jj_la1[105] = 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 DirectConstructor() throws ParseException {
 /*@bgen(jjtree) DirectConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRECTCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case StartTagOpen:
      case StartTagOpenRoot:
        DirElemConstructor();
        break;
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
        DirCommentConstructor();
        break;
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
        DirPIConstructor();
        break;
      default:
        jj_la1[106] = 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 DirElemConstructor() throws ParseException {
 /*@bgen(jjtree) DirElemConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRELEMCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case StartTagOpenRoot:
        jj_consume_token(StartTagOpenRoot);
                       SimpleNode jjtn001 = new SimpleNode(this, JJTSTARTTAGOPENROOT);
                       boolean jjtc001 = true;
                       jjtree.openNodeScope(jjtn001);
        try {
                       jjtree.closeNodeScope(jjtn001,  true);
                       jjtc001 = false;
                      jjtn001.processToken(token);
        } finally {
                       if (jjtc001) {
                         jjtree.closeNodeScope(jjtn001,  true);
                       }
        }
        break;
      case StartTagOpen:
        jj_consume_token(StartTagOpen);
                                                                                              SimpleNode jjtn002 = new SimpleNode(this, JJTSTARTTAGOPEN);
                                                                                              boolean jjtc002 = true;
                                                                                              jjtree.openNodeScope(jjtn002);
        try {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                              jjtc002 = false;
                                                                     jjtn002.processToken(token);
        } finally {
                                                                                              if (jjtc002) {
                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                              }
        }
        break;
      default:
        jj_la1[107] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(TagQName);
                                                                                                                                                            SimpleNode jjtn003 = new SimpleNode(this, JJTTAGQNAME);
                                                                                                                                                            boolean jjtc003 = true;
                                                                                                                                                            jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                            jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                            jjtc003 = false;
                                                                                                               jjtn003.processToken(token);
      } finally {
                                                                                                                                                            if (jjtc003) {
                                                                                                                                                              jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                            }
      }
      DirAttributeList();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EmptyTagClose:
        jj_consume_token(EmptyTagClose);
                                                                                                                                                                                                                                              SimpleNode jjtn004 = new SimpleNode(this, JJTEMPTYTAGCLOSE);
                                                                                                                                                                                                                                              boolean jjtc004 = true;
                                                                                                                                                                                                                                              jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                              jjtc004 = false;
                                                                                                                                                                                 jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                              if (jjtc004) {
                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                              }
        }
        break;
      case StartTagClose:
        jj_consume_token(StartTagClose);
                                                                                                                                                                                                                                                                                                                    SimpleNode jjtn005 = new SimpleNode(this, JJTSTARTTAGCLOSE);
                                                                                                                                                                                                                                                                                                                    boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                                    jjtree.openNodeScope(jjtn005);
        try {
                                                                                                                                                                                                                                                                                                                    jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                    jjtc005 = false;
                                                                                                                                                                                                                                  jjtn005.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                    if (jjtc005) {
                                                                                                                                                                                                                                                                                                                      jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                    }
        }
        label_25:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case ProcessingInstructionStart:
          case ProcessingInstructionStartForElementContent:
          case CdataSectionStart:
          case CdataSectionStartForElementContent:
          case PredefinedEntityRef:
          case CharRef:
          case StartTagOpen:
          case StartTagOpenRoot:
          case Lbrace:
          case LbraceExprEnclosure:
          case LCurlyBraceEscape:
          case RCurlyBraceEscape:
          case ElementContentChar:
          case XmlCommentStart:
          case XmlCommentStartForElementContent:
            ;
            break;
          default:
            jj_la1[108] = jj_gen;
            break label_25;
          }
          DirElemContent();
        }
        jj_consume_token(EndTagOpen);
                                                                                                                                                                                                                                                                                                                                                                                                        SimpleNode jjtn006 = new SimpleNode(this, JJTENDTAGOPEN);
                                                                                                                                                                                                                                                                                                                                                                                                        boolean jjtc006 = true;
                                                                                                                                                                                                                                                                                                                                                                                                        jjtree.openNodeScope(jjtn006);
        try {
                                                                                                                                                                                                                                                                                                                                                                                                        jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                                                        jjtc006 = false;
                                                                                                                                                                                                                                                                                                 jjtn006.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                                                                                        if (jjtc006) {
                                                                                                                                                                                                                                                                                                                                                                                                          jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                                                        }
        }
        jj_consume_token(TagQName);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   SimpleNode jjtn007 = new SimpleNode(this, JJTTAGQNAME);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   boolean jjtc007 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   jjtree.openNodeScope(jjtn007);
        try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   jjtc007 = false;
                                                                                                                                                                                                                                                                                                                                          jjtn007.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   if (jjtc007) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                     jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   }
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case S:
          jj_consume_token(S);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SimpleNode jjtn008 = new SimpleNode(this, JJTS);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      boolean jjtc008 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      jjtree.openNodeScope(jjtn008);
          try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      jjtree.closeNodeScope(jjtn008,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      jjtc008 = false;
                                                                                                                                                                                                                                                                                                                                                                             jjtn008.processToken(token);
          } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      if (jjtc008) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        jjtree.closeNodeScope(jjtn008,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
          }
          break;
        default:
          jj_la1[109] = jj_gen;
          ;
        }
        jj_consume_token(EndTagClose);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SimpleNode jjtn009 = new SimpleNode(this, JJTENDTAGCLOSE);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            boolean jjtc009 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            jjtree.openNodeScope(jjtn009);
        try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            jjtree.closeNodeScope(jjtn009,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            jjtc009 = false;
                                                                                                                                                                                                                                                                                                                                                                                                                          jjtn009.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            if (jjtc009) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn009,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
        }
        break;
      default:
        jj_la1[110] = 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 DirAttributeList() throws ParseException {
 /*@bgen(jjtree) DirAttributeList */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRATTRIBUTELIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_26:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case S:
          ;
          break;
        default:
          jj_la1[111] = jj_gen;
          break label_26;
        }
        jj_consume_token(S);
        SimpleNode jjtn001 = new SimpleNode(this, JJTS);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        try {
        jjtree.closeNodeScope(jjtn001,  true);
        jjtc001 = false;
       jjtn001.processToken(token);
        } finally {
        if (jjtc001) {
          jjtree.closeNodeScope(jjtn001,  true);
        }
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TagQName:
          jj_consume_token(TagQName);
                                                           SimpleNode jjtn002 = new SimpleNode(this, JJTTAGQNAME);
                                                           boolean jjtc002 = true;
                                                           jjtree.openNodeScope(jjtn002);
          try {
                                                           jjtree.closeNodeScope(jjtn002,  true);
                                                           jjtc002 = false;
                                                 jjtn002.processToken(token);
          } finally {
                                                           if (jjtc002) {
                                                             jjtree.closeNodeScope(jjtn002,  true);
                                                           }
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case S:
            jj_consume_token(S);
                                                                                                              SimpleNode jjtn003 = new SimpleNode(this, JJTS);
                                                                                                              boolean jjtc003 = true;
                                                                                                              jjtree.openNodeScope(jjtn003);
            try {
                                                                                                              jjtree.closeNodeScope(jjtn003,  true);
                                                                                                              jjtc003 = false;
                                                                                    jjtn003.processToken(token);
            } finally {
                                                                                                              if (jjtc003) {
                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
                                                                                                              }
            }
            break;
          default:
            jj_la1[112] = jj_gen;
            ;
          }
          jj_consume_token(ValueIndicator);
                                                                                                                                                                       SimpleNode jjtn004 = new SimpleNode(this, JJTVALUEINDICATOR);
                                                                                                                                                                       boolean jjtc004 = true;
                                                                                                                                                                       jjtree.openNodeScope(jjtn004);
          try {
                                                                                                                                                                       jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                       jjtc004 = false;
                                                                                                                                    jjtn004.processToken(token);
          } finally {
                                                                                                                                                                       if (jjtc004) {
                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                       }
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case S:
            jj_consume_token(S);
                                                                                                                                                                                                                                SimpleNode jjtn005 = new SimpleNode(this, JJTS);
                                                                                                                                                                                                                                boolean jjtc005 = true;
                                                                                                                                                                                                                                jjtree.openNodeScope(jjtn005);
            try {
                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                jjtc005 = false;
                                                                                                                                                                       jjtn005.processToken(token);
            } finally {
                                                                                                                                                                                                                                if (jjtc005) {
                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                }
            }
            break;
          default:
            jj_la1[113] = jj_gen;
            ;
          }
          DirAttributeValue();
          break;
        default:
          jj_la1[114] = 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 DirAttributeValue() throws ParseException {
 /*@bgen(jjtree) DirAttributeValue */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRATTRIBUTEVALUE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OpenQuot:
        jj_consume_token(OpenQuot);
                SimpleNode jjtn001 = new SimpleNode(this, JJTOPENQUOT);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
        try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
        } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
        }
        label_27:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case PredefinedEntityRef:
          case CharRef:
          case Lbrace:
          case LbraceExprEnclosure:
          case LCurlyBraceEscape:
          case RCurlyBraceEscape:
          case EscapeQuot:
          case QuotAttrContentChar:
            ;
            break;
          default:
            jj_la1[115] = jj_gen;
            break label_27;
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case EscapeQuot:
            jj_consume_token(EscapeQuot);
                                                                             SimpleNode jjtn002 = new SimpleNode(this, JJTESCAPEQUOT);
                                                                             boolean jjtc002 = true;
                                                                             jjtree.openNodeScope(jjtn002);
            try {
                                                                             jjtree.closeNodeScope(jjtn002,  true);
                                                                             jjtc002 = false;
                                                            jjtn002.processToken(token);
            } finally {
                                                                             if (jjtc002) {
                                                                               jjtree.closeNodeScope(jjtn002,  true);
                                                                             }
            }
            break;
          case PredefinedEntityRef:
          case CharRef:
          case Lbrace:
          case LbraceExprEnclosure:
          case LCurlyBraceEscape:
          case RCurlyBraceEscape:
          case QuotAttrContentChar:
            QuotAttrValueContent();
            break;
          default:
            jj_la1[116] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        jj_consume_token(CloseQuot);
                                                                                                                                                                     SimpleNode jjtn003 = new SimpleNode(this, JJTCLOSEQUOT);
                                                                                                                                                                     boolean jjtc003 = true;
                                                                                                                                                                     jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                     jjtc003 = false;
                                                                                                                                  jjtn003.processToken(token);
        } finally {
                                                                                                                                                                     if (jjtc003) {
                                                                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                     }
        }
        break;
      case OpenApos:
        jj_consume_token(OpenApos);
                                                                                                                                                                                                                                   SimpleNode jjtn004 = new SimpleNode(this, JJTOPENAPOS);
                                                                                                                                                                                                                                   boolean jjtc004 = true;
                                                                                                                                                                                                                                   jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                   jjtc004 = false;
                                                                                                                                                                               jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                   if (jjtc004) {
                                                                                                                                                                                                                                     jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                   }
        }
        label_28:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case PredefinedEntityRef:
          case CharRef:
          case Lbrace:
          case LbraceExprEnclosure:
          case LCurlyBraceEscape:
          case RCurlyBraceEscape:
          case EscapeApos:
          case AposAttrContentChar:
            ;
            break;
          default:
            jj_la1[117] = jj_gen;
            break label_28;
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case EscapeApos:
            jj_consume_token(EscapeApos);
                                                                                                                                                                                                                                                                                                SimpleNode jjtn005 = new SimpleNode(this, JJTESCAPEAPOS);
                                                                                                                                                                                                                                                                                                boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                jjtree.openNodeScope(jjtn005);
            try {
                                                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                jjtc005 = false;
                                                                                                                                                                                                                            jjtn005.processToken(token);
            } finally {
                                                                                                                                                                                                                                                                                                if (jjtc005) {
                                                                                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                }
            }
            break;
          case PredefinedEntityRef:
          case CharRef:
          case Lbrace:
          case LbraceExprEnclosure:
          case LCurlyBraceEscape:
          case RCurlyBraceEscape:
          case AposAttrContentChar:
            AposAttrValueContent();
            break;
          default:
            jj_la1[118] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        jj_consume_token(CloseApos);
                                                                                                                                                                                                                                                                                                                                                                                        SimpleNode jjtn006 = new SimpleNode(this, JJTCLOSEAPOS);
                                                                                                                                                                                                                                                                                                                                                                                        boolean jjtc006 = true;
                                                                                                                                                                                                                                                                                                                                                                                        jjtree.openNodeScope(jjtn006);
        try {
                                                                                                                                                                                                                                                                                                                                                                                        jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                                        jjtc006 = false;
                                                                                                                                                                                                                                                                                                  jjtn006.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                                                                                                        if (jjtc006) {
                                                                                                                                                                                                                                                                                                                                                                                          jjtree.closeNodeScope(jjtn006,  true);
                                                                                                                                                                                                                                                                                                                                                                                        }
        }
        break;
      default:
        jj_la1[119] = 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 QuotAttrValueContent() throws ParseException {
 /*@bgen(jjtree) QuotAttrValueContent */
  SimpleNode jjtn000 = new SimpleNode(this, JJTQUOTATTRVALUECONTENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QuotAttrContentChar:
        jj_consume_token(QuotAttrContentChar);
                          SimpleNode jjtn001 = new SimpleNode(this, JJTQUOTATTRCONTENTCHAR);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
        try {
                          jjtree.closeNodeScope(jjtn001,  true);
                          jjtc001 = false;
                         jjtn001.processToken(token);
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  true);
                          }
        }
        break;
      case PredefinedEntityRef:
      case CharRef:
      case Lbrace:
      case LbraceExprEnclosure:
      case LCurlyBraceEscape:
      case RCurlyBraceEscape:
        CommonContent();
        break;
      default:
        jj_la1[120] = 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 AposAttrValueContent() throws ParseException {
 /*@bgen(jjtree) AposAttrValueContent */
  SimpleNode jjtn000 = new SimpleNode(this, JJTAPOSATTRVALUECONTENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AposAttrContentChar:
        jj_consume_token(AposAttrContentChar);
                          SimpleNode jjtn001 = new SimpleNode(this, JJTAPOSATTRCONTENTCHAR);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
        try {
                          jjtree.closeNodeScope(jjtn001,  true);
                          jjtc001 = false;
                         jjtn001.processToken(token);
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  true);
                          }
        }
        break;
      case PredefinedEntityRef:
      case CharRef:
      case Lbrace:
      case LbraceExprEnclosure:
      case LCurlyBraceEscape:
      case RCurlyBraceEscape:
        CommonContent();
        break;
      default:
        jj_la1[121] = 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 DirElemContent() throws ParseException {
 /*@bgen(jjtree) DirElemContent */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRELEMCONTENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
        DirectConstructor();
        break;
      case ElementContentChar:
        jj_consume_token(ElementContentChar);
                                               SimpleNode jjtn001 = new SimpleNode(this, JJTELEMENTCONTENTCHAR);
                                               boolean jjtc001 = true;
                                               jjtree.openNodeScope(jjtn001);
        try {
                                               jjtree.closeNodeScope(jjtn001,  true);
                                               jjtc001 = false;
                                              jjtn001.processToken(token);
        } finally {
                                               if (jjtc001) {
                                                 jjtree.closeNodeScope(jjtn001,  true);
                                               }
        }
        break;
      case CdataSectionStart:
      case CdataSectionStartForElementContent:
        CDataSection();
        break;
      case PredefinedEntityRef:
      case CharRef:
      case Lbrace:
      case LbraceExprEnclosure:
      case LCurlyBraceEscape:
      case RCurlyBraceEscape:
        CommonContent();
        break;
      default:
        jj_la1[122] = 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 CommonContent() throws ParseException {
 /*@bgen(jjtree) CommonContent */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMMONCONTENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PredefinedEntityRef:
        jj_consume_token(PredefinedEntityRef);
                          SimpleNode jjtn001 = new SimpleNode(this, JJTPREDEFINEDENTITYREF);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
        try {
                          jjtree.closeNodeScope(jjtn001,  true);
                          jjtc001 = false;
                         jjtn001.processToken(token);
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  true);
                          }
        }
        break;
      case CharRef:
        jj_consume_token(CharRef);
                                                                                               SimpleNode jjtn002 = new SimpleNode(this, JJTCHARREF);
                                                                                               boolean jjtc002 = true;
                                                                                               jjtree.openNodeScope(jjtn002);
        try {
                                                                                               jjtree.closeNodeScope(jjtn002,  true);
                                                                                               jjtc002 = false;
                                                                   jjtn002.processToken(token);
        } finally {
                                                                                               if (jjtc002) {
                                                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                                                               }
        }
        break;
      case LCurlyBraceEscape:
        jj_consume_token(LCurlyBraceEscape);
                                                                                                                                                                  SimpleNode jjtn003 = new SimpleNode(this, JJTLCURLYBRACEESCAPE);
                                                                                                                                                                  boolean jjtc003 = true;
                                                                                                                                                                  jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                  jjtc003 = false;
                                                                                                                       jjtn003.processToken(token);
        } finally {
                                                                                                                                                                  if (jjtc003) {
                                                                                                                                                                    jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                  }
        }
        break;
      case RCurlyBraceEscape:
        jj_consume_token(RCurlyBraceEscape);
                                                                                                                                                                                                                                               SimpleNode jjtn004 = new SimpleNode(this, JJTRCURLYBRACEESCAPE);
                                                                                                                                                                                                                                               boolean jjtc004 = true;
                                                                                                                                                                                                                                               jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                               jjtc004 = false;
                                                                                                                                                                           jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                               if (jjtc004) {
                                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                               }
        }
        break;
      case Lbrace:
      case LbraceExprEnclosure:
        EnclosedExpr();
        break;
      default:
        jj_la1[123] = 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 DirCommentConstructor() throws ParseException {
 /*@bgen(jjtree) DirCommentConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRCOMMENTCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case XmlCommentStartForElementContent:
        jj_consume_token(XmlCommentStartForElementContent);
                                       SimpleNode jjtn001 = new SimpleNode(this, JJTXMLCOMMENTSTARTFORELEMENTCONTENT);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
        try {
                                       jjtree.closeNodeScope(jjtn001,  true);
                                       jjtc001 = false;
                                      jjtn001.processToken(token);
        } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                       }
        }
        break;
      case XmlCommentStart:
        jj_consume_token(XmlCommentStart);
                                                                                                                                 SimpleNode jjtn002 = new SimpleNode(this, JJTXMLCOMMENTSTART);
                                                                                                                                 boolean jjtc002 = true;
                                                                                                                                 jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                 jjtc002 = false;
                                                                                        jjtn002.processToken(token);
        } finally {
                                                                                                                                 if (jjtc002) {
                                                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                 }
        }
        break;
      default:
        jj_la1[124] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      DirCommentContents();
      jj_consume_token(XmlCommentEnd);
                                                                                                                                                                                                                            SimpleNode jjtn003 = new SimpleNode(this, JJTXMLCOMMENTEND);
                                                                                                                                                                                                                            boolean jjtc003 = true;
                                                                                                                                                                                                                            jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                                                                            jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                            jjtc003 = false;
                                                                                                                                                            jjtn003.processToken(token);
      } finally {
                                                                                                                                                                                                                            if (jjtc003) {
                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                            }
      }
    } 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 DirCommentContents() throws ParseException {
 /*@bgen(jjtree) DirCommentContents */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRCOMMENTCONTENTS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_29:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CommentContentChar:
        case CommentContentCharDash:
          ;
          break;
        default:
          jj_la1[125] = jj_gen;
          break label_29;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CommentContentChar:
          jj_consume_token(CommentContentChar);
                          SimpleNode jjtn001 = new SimpleNode(this, JJTCOMMENTCONTENTCHAR);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
          try {
                          jjtree.closeNodeScope(jjtn001,  true);
                          jjtc001 = false;
                         jjtn001.processToken(token);
          } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  true);
                          }
          }
          break;
        case CommentContentCharDash:
          jj_consume_token(CommentContentCharDash);
                                                                                                             SimpleNode jjtn002 = new SimpleNode(this, JJTCOMMENTCONTENTCHARDASH);
                                                                                                             boolean jjtc002 = true;
                                                                                                             jjtree.openNodeScope(jjtn002);
          try {
                                                                                                             jjtree.closeNodeScope(jjtn002,  true);
                                                                                                             jjtc002 = false;
                                                                                  jjtn002.processToken(token);
          } finally {
                                                                                                             if (jjtc002) {
                                                                                                               jjtree.closeNodeScope(jjtn002,  true);
                                                                                                             }
          }
          break;
        default:
          jj_la1[126] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void DirPIConstructor() throws ParseException {
 /*@bgen(jjtree) DirPIConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRPICONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ProcessingInstructionStartForElementContent:
        jj_consume_token(ProcessingInstructionStartForElementContent);
                                                  SimpleNode jjtn001 = new SimpleNode(this, JJTPROCESSINGINSTRUCTIONSTARTFORELEMENTCONTENT);
                                                  boolean jjtc001 = true;
                                                  jjtree.openNodeScope(jjtn001);
        try {
                                                  jjtree.closeNodeScope(jjtn001,  true);
                                                  jjtc001 = false;
                                                 jjtn001.processToken(token);
        } finally {
                                                  if (jjtc001) {
                                                    jjtree.closeNodeScope(jjtn001,  true);
                                                  }
        }
        break;
      case ProcessingInstructionStart:
        jj_consume_token(ProcessingInstructionStart);
                                                                                                                                                                  SimpleNode jjtn002 = new SimpleNode(this, JJTPROCESSINGINSTRUCTIONSTART);
                                                                                                                                                                  boolean jjtc002 = true;
                                                                                                                                                                  jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                                                  jjtc002 = false;
                                                                                                              jjtn002.processToken(token);
        } finally {
                                                                                                                                                                  if (jjtc002) {
                                                                                                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                                                  }
        }
        break;
      default:
        jj_la1[127] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(PITarget);
                                                                                                                                                                                                                                              SimpleNode jjtn003 = new SimpleNode(this, JJTPITARGET);
                                                                                                                                                                                                                                              boolean jjtc003 = true;
                                                                                                                                                                                                                                              jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                                              jjtc003 = false;
                                                                                                                                                        jjtn003.processToken(token);
      } finally {
                                                                                                                                                                                                                                              if (jjtc003) {
                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                                              }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SForPI:
        jj_consume_token(SForPI);
                                                                                                                                                                                                                                                                                                      SimpleNode jjtn004 = new SimpleNode(this, JJTSFORPI);
                                                                                                                                                                                                                                                                                                      boolean jjtc004 = true;
                                                                                                                                                                                                                                                                                                      jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                                                                                      jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                                                      jjtc004 = false;
                                                                                                                                                                                                jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                                                                                      if (jjtc004) {
                                                                                                                                                                                                                                                                                                        jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                                                      }
        }
        DirPIContents();
        break;
      default:
        jj_la1[128] = jj_gen;
        ;
      }
      jj_consume_token(ProcessingInstructionEnd);
                                                                                                                                                                                                                                                                                                                                                                                              SimpleNode jjtn005 = new SimpleNode(this, JJTPROCESSINGINSTRUCTIONEND);
                                                                                                                                                                                                                                                                                                                                                                                              boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                                                                                                              jjtree.openNodeScope(jjtn005);
      try {
                                                                                                                                                                                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                                                                                              jjtc005 = false;
                                                                                                                                                                                                                                                                          jjtn005.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                              if (jjtc005) {
                                                                                                                                                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                                                                                              }
      }
    } 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 DirPIContents() throws ParseException {
 /*@bgen(jjtree) DirPIContents */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDIRPICONTENTS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_30:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case PIContentChar:
          ;
          break;
        default:
          jj_la1[129] = jj_gen;
          break label_30;
        }
        jj_consume_token(PIContentChar);
                    SimpleNode jjtn001 = new SimpleNode(this, JJTPICONTENTCHAR);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
        try {
                    jjtree.closeNodeScope(jjtn001,  true);
                    jjtc001 = false;
                   jjtn001.processToken(token);
        } finally {
                    if (jjtc001) {
                      jjtree.closeNodeScope(jjtn001,  true);
                    }
        }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void CDataSection() throws ParseException {
 /*@bgen(jjtree) CDataSection */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCDATASECTION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CdataSectionStartForElementContent:
        jj_consume_token(CdataSectionStartForElementContent);
                                         SimpleNode jjtn001 = new SimpleNode(this, JJTCDATASECTIONSTARTFORELEMENTCONTENT);
                                         boolean jjtc001 = true;
                                         jjtree.openNodeScope(jjtn001);
        try {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                         jjtc001 = false;
                                        jjtn001.processToken(token);
        } finally {
                                         if (jjtc001) {
                                           jjtree.closeNodeScope(jjtn001,  true);
                                         }
        }
        break;
      case CdataSectionStart:
        jj_consume_token(CdataSectionStart);
                                                                                                                                       SimpleNode jjtn002 = new SimpleNode(this, JJTCDATASECTIONSTART);
                                                                                                                                       boolean jjtc002 = true;
                                                                                                                                       jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                                       jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                       jjtc002 = false;
                                                                                            jjtn002.processToken(token);
        } finally {
                                                                                                                                       if (jjtc002) {
                                                                                                                                         jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                       }
        }
        break;
      default:
        jj_la1[130] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      CDataSectionContents();
      jj_consume_token(CdataSectionEnd);
                                                                                                                                                                                                                                        SimpleNode jjtn003 = new SimpleNode(this, JJTCDATASECTIONEND);
                                                                                                                                                                                                                                        boolean jjtc003 = true;
                                                                                                                                                                                                                                        jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                                                                                        jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                                        jjtc003 = false;
                                                                                                                                                                    jjtn003.processToken(token);
      } finally {
                                                                                                                                                                                                                                        if (jjtc003) {
                                                                                                                                                                                                                                          jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                                        }
      }
    } 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 CDataSectionContents() throws ParseException {
 /*@bgen(jjtree) CDataSectionContents */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCDATASECTIONCONTENTS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_31:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CDataSectionChar:
          ;
          break;
        default:
          jj_la1[131] = jj_gen;
          break label_31;
        }
        jj_consume_token(CDataSectionChar);
                       SimpleNode jjtn001 = new SimpleNode(this, JJTCDATASECTIONCHAR);
                       boolean jjtc001 = true;
                       jjtree.openNodeScope(jjtn001);
        try {
                       jjtree.closeNodeScope(jjtn001,  true);
                       jjtc001 = false;
                      jjtn001.processToken(token);
        } finally {
                       if (jjtc001) {
                         jjtree.closeNodeScope(jjtn001,  true);
                       }
        }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ComputedConstructor() throws ParseException {
 /*@bgen(jjtree) ComputedConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPUTEDCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DocumentLbrace:
        CompDocConstructor();
        break;
      case ElementQNameLbrace:
      case ElementLbrace:
        CompElemConstructor();
        break;
      case AttributeQNameLbrace:
      case AttributeLbrace:
        CompAttrConstructor();
        break;
      case TextLbrace:
        CompTextConstructor();
        break;
      case CommentLbrace:
        CompCommentConstructor();
        break;
      case PINCNameLbrace:
      case PILbrace:
        CompPIConstructor();
        break;
      default:
        jj_la1[132] = 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 CompDocConstructor() throws ParseException {
 /*@bgen(jjtree) CompDocConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPDOCCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(DocumentLbrace);
                    SimpleNode jjtn001 = new SimpleNode(this, JJTDOCUMENTLBRACE);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
      try {
                    jjtree.closeNodeScope(jjtn001,  true);
                    jjtc001 = false;
                   jjtn001.processToken(token);
      } finally {
                    if (jjtc001) {
                      jjtree.closeNodeScope(jjtn001,  true);
                    }
      }
      Expr();
      jj_consume_token(Rbrace);
                                                                                        SimpleNode jjtn002 = new SimpleNode(this, JJTRBRACE);
                                                                                        boolean jjtc002 = true;
                                                                                        jjtree.openNodeScope(jjtn002);
      try {
                                                                                        jjtree.closeNodeScope(jjtn002,  true);
                                                                                        jjtc002 = false;
                                                                 jjtn002.processToken(token);
      } finally {
                                                                                        if (jjtc002) {
                                                                                          jjtree.closeNodeScope(jjtn002,  true);
                                                                                        }
      }
    } 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 CompElemConstructor() throws ParseException {
 /*@bgen(jjtree) CompElemConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPELEMCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ElementQNameLbrace:
        jj_consume_token(ElementQNameLbrace);
                         SimpleNode jjtn001 = new SimpleNode(this, JJTELEMENTQNAMELBRACE);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
        try {
                         jjtree.closeNodeScope(jjtn001,  true);
                         jjtc001 = false;
                        jjtn001.processToken(token);
        } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001,  true);
                         }
        }
        break;
      case ElementLbrace:
        jj_consume_token(ElementLbrace);
                                                                                                    SimpleNode jjtn002 = new SimpleNode(this, JJTELEMENTLBRACE);
                                                                                                    boolean jjtc002 = true;
                                                                                                    jjtree.openNodeScope(jjtn002);
        try {
                                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                                    jjtc002 = false;
                                                                         jjtn002.processToken(token);
        } finally {
                                                                                                    if (jjtc002) {
                                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                                    }
        }
        Expr();
        jj_consume_token(Rbrace);
                                                                                                                                                                       SimpleNode jjtn003 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                                       boolean jjtc003 = true;
                                                                                                                                                                       jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                       jjtc003 = false;
                                                                                                                       jjtn003.processToken(token);
        } finally {
                                                                                                                                                                       if (jjtc003) {
                                                                                                                                                                         jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                       }
        }
        jj_consume_token(LbraceExprEnclosure);
                                                                                                                                                                                                                                         SimpleNode jjtn004 = new SimpleNode(this, JJTLBRACEEXPRENCLOSURE);
                                                                                                                                                                                                                                         boolean jjtc004 = true;
                                                                                                                                                                                                                                         jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                         jjtc004 = false;
                                                                                                                                                                           jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                         if (jjtc004) {
                                                                                                                                                                                                                                           jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                         }
        }
        break;
      default:
        jj_la1[133] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case VariableIndicator:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case OrderedOpen:
      case UnorderedOpen:
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Root:
      case RootDescendants:
      case UnaryMinus:
      case UnaryPlus:
      case Lpar:
      case At:
      case Some:
      case Every:
      case ForVariable:
      case LetVariable:
      case ValidateLbrace:
      case ValidateSchemaMode:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case DocumentLbrace:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case IfLpar:
      case TypeswitchLpar:
      case Dot:
      case DotDot:
      case QNameLpar:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
      case QName:
        ContentExpr();
        break;
      default:
        jj_la1[134] = jj_gen;
        ;
      }
      jj_consume_token(Rbrace);
                                                                                                                                                                                                                                                                                                                             SimpleNode jjtn005 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                                                                                                                                                                                             boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                                             jjtree.openNodeScope(jjtn005);
      try {
                                                                                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                             jjtc005 = false;
                                                                                                                                                                                                                                    jjtn005.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                             if (jjtc005) {
                                                                                                                                                                                                                                                                                                                               jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                             }
      }
    } 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 ContentExpr() throws ParseException {
 /*@bgen(jjtree) ContentExpr */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCONTENTEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Expr();
    } 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 CompAttrConstructor() throws ParseException {
 /*@bgen(jjtree) CompAttrConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPATTRCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AttributeQNameLbrace:
        jj_consume_token(AttributeQNameLbrace);
                           SimpleNode jjtn001 = new SimpleNode(this, JJTATTRIBUTEQNAMELBRACE);
                           boolean jjtc001 = true;
                           jjtree.openNodeScope(jjtn001);
        try {
                           jjtree.closeNodeScope(jjtn001,  true);
                           jjtc001 = false;
                          jjtn001.processToken(token);
        } finally {
                           if (jjtc001) {
                             jjtree.closeNodeScope(jjtn001,  true);
                           }
        }
        break;
      case AttributeLbrace:
        jj_consume_token(AttributeLbrace);
                                                                                                          SimpleNode jjtn002 = new SimpleNode(this, JJTATTRIBUTELBRACE);
                                                                                                          boolean jjtc002 = true;
                                                                                                          jjtree.openNodeScope(jjtn002);
        try {
                                                                                                          jjtree.closeNodeScope(jjtn002,  true);
                                                                                                          jjtc002 = false;
                                                                             jjtn002.processToken(token);
        } finally {
                                                                                                          if (jjtc002) {
                                                                                                            jjtree.closeNodeScope(jjtn002,  true);
                                                                                                          }
        }
        Expr();
        jj_consume_token(Rbrace);
                                                                                                                                                                               SimpleNode jjtn003 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                                               boolean jjtc003 = true;
                                                                                                                                                                               jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                               jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               jjtc003 = false;
                                                                                                                           jjtn003.processToken(token);
        } finally {
                                                                                                                                                                               if (jjtc003) {
                                                                                                                                                                                 jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                               }
        }
        jj_consume_token(LbraceExprEnclosure);
                                                                                                                                                                                                                                                 SimpleNode jjtn004 = new SimpleNode(this, JJTLBRACEEXPRENCLOSURE);
                                                                                                                                                                                                                                                 boolean jjtc004 = true;
                                                                                                                                                                                                                                                 jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                 jjtc004 = false;
                                                                                                                                                                               jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                                                 if (jjtc004) {
                                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                 }
        }
        break;
      default:
        jj_la1[135] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case VariableIndicator:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case OrderedOpen:
      case UnorderedOpen:
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Root:
      case RootDescendants:
      case UnaryMinus:
      case UnaryPlus:
      case Lpar:
      case At:
      case Some:
      case Every:
      case ForVariable:
      case LetVariable:
      case ValidateLbrace:
      case ValidateSchemaMode:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case DocumentLbrace:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case IfLpar:
      case TypeswitchLpar:
      case Dot:
      case DotDot:
      case QNameLpar:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
      case QName:
        Expr();
        break;
      default:
        jj_la1[136] = jj_gen;
        ;
      }
      jj_consume_token(Rbrace);
                                                                                                                                                                                                                                                                                                                              SimpleNode jjtn005 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                                                                                                                                                                                              boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                                              jjtree.openNodeScope(jjtn005);
      try {
                                                                                                                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                              jjtc005 = false;
                                                                                                                                                                                                                                 jjtn005.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                              if (jjtc005) {
                                                                                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                              }
      }
    } 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 CompTextConstructor() throws ParseException {
 /*@bgen(jjtree) CompTextConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPTEXTCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(TextLbrace);
                SimpleNode jjtn001 = new SimpleNode(this, JJTTEXTLBRACE);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
      try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
      } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
      }
      Expr();
      jj_consume_token(Rbrace);
                                                                                SimpleNode jjtn002 = new SimpleNode(this, JJTRBRACE);
                                                                                boolean jjtc002 = true;
                                                                                jjtree.openNodeScope(jjtn002);
      try {
                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                jjtc002 = false;
                                                             jjtn002.processToken(token);
      } finally {
                                                                                if (jjtc002) {
                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                }
      }
    } 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 CompCommentConstructor() throws ParseException {
 /*@bgen(jjtree) CompCommentConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPCOMMENTCONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(CommentLbrace);
                   SimpleNode jjtn001 = new SimpleNode(this, JJTCOMMENTLBRACE);
                   boolean jjtc001 = true;
                   jjtree.openNodeScope(jjtn001);
      try {
                   jjtree.closeNodeScope(jjtn001,  true);
                   jjtc001 = false;
                  jjtn001.processToken(token);
      } finally {
                   if (jjtc001) {
                     jjtree.closeNodeScope(jjtn001,  true);
                   }
      }
      Expr();
      jj_consume_token(Rbrace);
                                                                                      SimpleNode jjtn002 = new SimpleNode(this, JJTRBRACE);
                                                                                      boolean jjtc002 = true;
                                                                                      jjtree.openNodeScope(jjtn002);
      try {
                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                      jjtc002 = false;
                                                                jjtn002.processToken(token);
      } finally {
                                                                                      if (jjtc002) {
                                                                                        jjtree.closeNodeScope(jjtn002,  true);
                                                                                      }
      }
    } 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 CompPIConstructor() throws ParseException {
 /*@bgen(jjtree) CompPIConstructor */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMPPICONSTRUCTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PINCNameLbrace:
        jj_consume_token(PINCNameLbrace);
                     SimpleNode jjtn001 = new SimpleNode(this, JJTPINCNAMELBRACE);
                     boolean jjtc001 = true;
                     jjtree.openNodeScope(jjtn001);
        try {
                     jjtree.closeNodeScope(jjtn001,  true);
                     jjtc001 = false;
                    jjtn001.processToken(token);
        } finally {
                     if (jjtc001) {
                       jjtree.closeNodeScope(jjtn001,  true);
                     }
        }
        break;
      case PILbrace:
        jj_consume_token(PILbrace);
                                                                                       SimpleNode jjtn002 = new SimpleNode(this, JJTPILBRACE);
                                                                                       boolean jjtc002 = true;
                                                                                       jjtree.openNodeScope(jjtn002);
        try {
                                                                                       jjtree.closeNodeScope(jjtn002,  true);
                                                                                       jjtc002 = false;
                                                                jjtn002.processToken(token);
        } finally {
                                                                                       if (jjtc002) {
                                                                                         jjtree.closeNodeScope(jjtn002,  true);
                                                                                       }
        }
        Expr();
        jj_consume_token(Rbrace);
                                                                                                                                                     SimpleNode jjtn003 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                     boolean jjtc003 = true;
                                                                                                                                                     jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                     jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                     jjtc003 = false;
                                                                                                              jjtn003.processToken(token);
        } finally {
                                                                                                                                                     if (jjtc003) {
                                                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                     }
        }
        jj_consume_token(LbraceExprEnclosure);
                                                                                                                                                                                                                       SimpleNode jjtn004 = new SimpleNode(this, JJTLBRACEEXPRENCLOSURE);
                                                                                                                                                                                                                       boolean jjtc004 = true;
                                                                                                                                                                                                                       jjtree.openNodeScope(jjtn004);
        try {
                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                       jjtc004 = false;
                                                                                                                                                                  jjtn004.processToken(token);
        } finally {
                                                                                                                                                                                                                       if (jjtc004) {
                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                       }
        }
        break;
      default:
        jj_la1[137] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case ProcessingInstructionStart:
      case ProcessingInstructionStartForElementContent:
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case VariableIndicator:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case OrderedOpen:
      case UnorderedOpen:
      case ElementQNameLbrace:
      case AttributeQNameLbrace:
      case PINCNameLbrace:
      case PILbrace:
      case CommentLbrace:
      case ElementLbrace:
      case AttributeLbrace:
      case TextLbrace:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Root:
      case RootDescendants:
      case UnaryMinus:
      case UnaryPlus:
      case Lpar:
      case At:
      case Some:
      case Every:
      case ForVariable:
      case LetVariable:
      case ValidateLbrace:
      case ValidateSchemaMode:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case DocumentLbrace:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case IfLpar:
      case TypeswitchLpar:
      case Dot:
      case DotDot:
      case QNameLpar:
      case StartTagOpen:
      case StartTagOpenRoot:
      case XmlCommentStart:
      case XmlCommentStartForElementContent:
      case QName:
        Expr();
        break;
      default:
        jj_la1[138] = jj_gen;
        ;
      }
      jj_consume_token(Rbrace);
                                                                                                                                                                                                                                                                                                    SimpleNode jjtn005 = new SimpleNode(this, JJTRBRACE);
                                                                                                                                                                                                                                                                                                    boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                    jjtree.openNodeScope(jjtn005);
      try {
                                                                                                                                                                                                                                                                                                    jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                    jjtc005 = false;
                                                                                                                                                                                                                    jjtn005.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                    if (jjtc005) {
                                                                                                                                                                                                                                                                                                      jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                    }
      }
    } 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 SingleType() throws ParseException {
 /*@bgen(jjtree) SingleType */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSINGLETYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      AtomicType();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OccurrenceZeroOrOne:
        jj_consume_token(OccurrenceZeroOrOne);
                                       SimpleNode jjtn001 = new SimpleNode(this, JJTOCCURRENCEZEROORONE);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
        try {
                                       jjtree.closeNodeScope(jjtn001,  true);
                                       jjtc001 = false;
                                      jjtn001.processToken(token);
        } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                       }
        }
        break;
      default:
        jj_la1[139] = 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 TypeDeclaration() throws ParseException {
 /*@bgen(jjtree) TypeDeclaration */
  SimpleNode jjtn000 = new SimpleNode(this, JJTTYPEDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(As);
        SimpleNode jjtn001 = new SimpleNode(this, JJTAS);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
      try {
        jjtree.closeNodeScope(jjtn001,  true);
        jjtc001 = false;
       jjtn001.processToken(token);
      } finally {
        if (jjtc001) {
          jjtree.closeNodeScope(jjtn001,  true);
        }
      }
      SequenceType();
    } 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 SequenceType() throws ParseException {
 /*@bgen(jjtree) SequenceType */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSEQUENCETYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Item:
      case ElementType:
      case AttributeType:
      case SchemaElementType:
      case SchemaAttributeType:
      case DocumentLpar:
      case DocumentLparForKindTest:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case AttributeTypeForKindTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
      case SchemaAttributeTypeForKindTest:
      case ProcessingInstructionLparForKindTest:
      case TextLparForKindTest:
      case CommentLparForKindTest:
      case NodeLparForKindTest:
      case QNameForSequenceType:
      case QNameForAtomicType:
        ItemType();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OccurrenceZeroOrOne:
        case OccurrenceZeroOrMore:
        case OccurrenceOneOrMore:
          OccurrenceIndicator();
          break;
        default:
          jj_la1[140] = jj_gen;
          ;
        }
        break;
      case EmptyTok:
        jj_consume_token(EmptyTok);
                                                      SimpleNode jjtn001 = new SimpleNode(this, JJTEMPTYTOK);
                                                      boolean jjtc001 = true;
                                                      jjtree.openNodeScope(jjtn001);
        try {
                                                      jjtree.closeNodeScope(jjtn001,  true);
                                                      jjtc001 = false;
                                                     jjtn001.processToken(token);
        } finally {
                                                      if (jjtc001) {
                                                        jjtree.closeNodeScope(jjtn001,  true);
                                                      }
        }
        break;
      default:
        jj_la1[141] = 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 OccurrenceIndicator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case OccurrenceZeroOrOne:
      jj_consume_token(OccurrenceZeroOrOne);
                          SimpleNode jjtn001 = new SimpleNode(this, JJTOCCURRENCEZEROORONE);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
      try {
                          jjtree.closeNodeScope(jjtn001,  true);
                          jjtc001 = false;
                         jjtn001.processToken(token);
      } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  true);
                          }
      }
      break;
    case OccurrenceZeroOrMore:
      jj_consume_token(OccurrenceZeroOrMore);
                                                                                                            SimpleNode jjtn002 = new SimpleNode(this, JJTOCCURRENCEZEROORMORE);
                                                                                                            boolean jjtc002 = true;
                                                                                                            jjtree.openNodeScope(jjtn002);
      try {
                                                                                                            jjtree.closeNodeScope(jjtn002,  true);
                                                                                                            jjtc002 = false;
                                                                                jjtn002.processToken(token);
      } finally {
                                                                                                            if (jjtc002) {
                                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                                            }
      }
      break;
    case OccurrenceOneOrMore:
      jj_consume_token(OccurrenceOneOrMore);
                                                                                                                                                                                              SimpleNode jjtn003 = new SimpleNode(this, JJTOCCURRENCEONEORMORE);
                                                                                                                                                                                              boolean jjtc003 = true;
                                                                                                                                                                                              jjtree.openNodeScope(jjtn003);
      try {
                                                                                                                                                                                              jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                              jjtc003 = false;
                                                                                                                                      jjtn003.processToken(token);
      } finally {
                                                                                                                                                                                              if (jjtc003) {
                                                                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                              }
      }
      break;
    default:
      jj_la1[142] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ItemType() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case QNameForSequenceType:
    case QNameForAtomicType:
      AtomicType();
      break;
    case ElementType:
    case AttributeType:
    case SchemaElementType:
    case SchemaAttributeType:
    case DocumentLpar:
    case DocumentLparForKindTest:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case ElementTypeForKindTest:
    case ElementTypeForDocumentTest:
    case AttributeTypeForKindTest:
    case SchemaElementTypeForKindTest:
    case SchemaElementTypeForDocumentTest:
    case SchemaAttributeTypeForKindTest:
    case ProcessingInstructionLparForKindTest:
    case TextLparForKindTest:
    case CommentLparForKindTest:
    case NodeLparForKindTest:
      KindTest();
      break;
    case Item:
      jj_consume_token(Item);
                                       SimpleNode jjtn001 = new SimpleNode(this, JJTITEM);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
      try {
                                       jjtree.closeNodeScope(jjtn001,  true);
                                       jjtc001 = false;
                                      jjtn001.processToken(token);
      } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                       }
      }
      break;
    default:
      jj_la1[143] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void AtomicType() throws ParseException {
 /*@bgen(jjtree) AtomicType */
  SimpleNode jjtn000 = new SimpleNode(this, JJTATOMICTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QNameForAtomicType:
        jj_consume_token(QNameForAtomicType);
                         SimpleNode jjtn001 = new SimpleNode(this, JJTQNAMEFORATOMICTYPE);
                         boolean jjtc001 = true;
                         jjtree.openNodeScope(jjtn001);
        try {
                         jjtree.closeNodeScope(jjtn001,  true);
                         jjtc001 = false;
                        jjtn001.processToken(token);
        } finally {
                         if (jjtc001) {
                           jjtree.closeNodeScope(jjtn001,  true);
                         }
        }
        break;
      case QNameForSequenceType:
        jj_consume_token(QNameForSequenceType);
                                                                                                          SimpleNode jjtn002 = new SimpleNode(this, JJTQNAMEFORSEQUENCETYPE);
                                                                                                          boolean jjtc002 = true;
                                                                                                          jjtree.openNodeScope(jjtn002);
        try {
                                                                                                          jjtree.closeNodeScope(jjtn002,  true);
                                                                                                          jjtc002 = false;
                                                                               jjtn002.processToken(token);
        } finally {
                                                                                                          if (jjtc002) {
                                                                                                            jjtree.closeNodeScope(jjtn002,  true);
                                                                                                          }
        }
        break;
      default:
        jj_la1[144] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void KindTest() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case DocumentLpar:
    case DocumentLparForKindTest:
      DocumentTest();
      break;
    case ElementType:
    case ElementTypeForKindTest:
    case ElementTypeForDocumentTest:
      ElementTest();
      break;
    case AttributeType:
    case AttributeTypeForKindTest:
      AttributeTest();
      break;
    case SchemaElementType:
    case SchemaElementTypeForKindTest:
    case SchemaElementTypeForDocumentTest:
      SchemaElementTest();
      break;
    case SchemaAttributeType:
    case SchemaAttributeTypeForKindTest:
      SchemaAttributeTest();
      break;
    case ProcessingInstructionLpar:
    case ProcessingInstructionLparForKindTest:
      PITest();
      break;
    case CommentLpar:
    case CommentLparForKindTest:
      CommentTest();
      break;
    case TextLpar:
    case TextLparForKindTest:
      TextTest();
      break;
    case NodeLpar:
    case NodeLparForKindTest:
      AnyKindTest();
      break;
    default:
      jj_la1[145] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void AnyKindTest() throws ParseException {
 /*@bgen(jjtree) AnyKindTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTANYKINDTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NodeLpar:
        jj_consume_token(NodeLpar);
        break;
      case NodeLparForKindTest:
        jj_consume_token(NodeLparForKindTest);
                                       SimpleNode jjtn001 = new SimpleNode(this, JJTNODELPARFORKINDTEST);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
        try {
                                       jjtree.closeNodeScope(jjtn001,  true);
                                       jjtc001 = false;
                                      jjtn001.processToken(token);
        } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                       }
        }
        break;
      default:
        jj_la1[146] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(RparForKindTest);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void DocumentTest() throws ParseException {
 /*@bgen(jjtree) DocumentTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTDOCUMENTTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case DocumentLpar:
        jj_consume_token(DocumentLpar);
                   SimpleNode jjtn001 = new SimpleNode(this, JJTDOCUMENTLPAR);
                   boolean jjtc001 = true;
                   jjtree.openNodeScope(jjtn001);
        try {
                   jjtree.closeNodeScope(jjtn001,  true);
                   jjtc001 = false;
                  jjtn001.processToken(token);
        } finally {
                   if (jjtc001) {
                     jjtree.closeNodeScope(jjtn001,  true);
                   }
        }
        break;
      case DocumentLparForKindTest:
        jj_consume_token(DocumentLparForKindTest);
                                                                                                 SimpleNode jjtn002 = new SimpleNode(this, JJTDOCUMENTLPARFORKINDTEST);
                                                                                                 boolean jjtc002 = true;
                                                                                                 jjtree.openNodeScope(jjtn002);
        try {
                                                                                                 jjtree.closeNodeScope(jjtn002,  true);
                                                                                                 jjtc002 = false;
                                                                            jjtn002.processToken(token);
        } finally {
                                                                                                 if (jjtc002) {
                                                                                                   jjtree.closeNodeScope(jjtn002,  true);
                                                                                                 }
        }
        break;
      default:
        jj_la1[147] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ElementType:
      case SchemaElementType:
      case ElementTypeForKindTest:
      case ElementTypeForDocumentTest:
      case SchemaElementTypeForKindTest:
      case SchemaElementTypeForDocumentTest:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ElementType:
        case ElementTypeForKindTest:
        case ElementTypeForDocumentTest:
          ElementTest();
          break;
        case SchemaElementType:
        case SchemaElementTypeForKindTest:
        case SchemaElementTypeForDocumentTest:
          SchemaElementTest();
          break;
        default:
          jj_la1[148] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[149] = jj_gen;
        ;
      }
      jj_consume_token(RparForKindTest);
    } 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 TextTest() throws ParseException {
 /*@bgen(jjtree) TextTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTTEXTTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TextLpar:
        jj_consume_token(TextLpar);
        break;
      case TextLparForKindTest:
        jj_consume_token(TextLparForKindTest);
                                       SimpleNode jjtn001 = new SimpleNode(this, JJTTEXTLPARFORKINDTEST);
                                       boolean jjtc001 = true;
                                       jjtree.openNodeScope(jjtn001);
        try {
                                       jjtree.closeNodeScope(jjtn001,  true);
                                       jjtc001 = false;
                                      jjtn001.processToken(token);
        } finally {
                                       if (jjtc001) {
                                         jjtree.closeNodeScope(jjtn001,  true);
                                       }
        }
        break;
      default:
        jj_la1[150] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(RparForKindTest);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void CommentTest() throws ParseException {
 /*@bgen(jjtree) CommentTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTCOMMENTTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CommentLpar:
        jj_consume_token(CommentLpar);
        break;
      case CommentLparForKindTest:
        jj_consume_token(CommentLparForKindTest);
                                             SimpleNode jjtn001 = new SimpleNode(this, JJTCOMMENTLPARFORKINDTEST);
                                             boolean jjtc001 = true;
                                             jjtree.openNodeScope(jjtn001);
        try {
                                             jjtree.closeNodeScope(jjtn001,  true);
                                             jjtc001 = false;
                                            jjtn001.processToken(token);
        } finally {
                                             if (jjtc001) {
                                               jjtree.closeNodeScope(jjtn001,  true);
                                             }
        }
        break;
      default:
        jj_la1[151] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(RparForKindTest);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void PITest() throws ParseException {
 /*@bgen(jjtree) PITest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTPITEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ProcessingInstructionLpar:
        jj_consume_token(ProcessingInstructionLpar);
        break;
      case ProcessingInstructionLparForKindTest:
        jj_consume_token(ProcessingInstructionLparForKindTest);
                                                                         SimpleNode jjtn001 = new SimpleNode(this, JJTPROCESSINGINSTRUCTIONLPARFORKINDTEST);
                                                                         boolean jjtc001 = true;
                                                                         jjtree.openNodeScope(jjtn001);
        try {
                                                                         jjtree.closeNodeScope(jjtn001,  true);
                                                                         jjtc001 = false;
                                                                        jjtn001.processToken(token);
        } finally {
                                                                         if (jjtc001) {
                                                                           jjtree.closeNodeScope(jjtn001,  true);
                                                                         }
        }
        break;
      default:
        jj_la1[152] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case StringLiteralForKindTest:
      case NCNameForPI:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NCNameForPI:
          jj_consume_token(NCNameForPI);
                                                                                                                                                                    SimpleNode jjtn002 = new SimpleNode(this, JJTNCNAMEFORPI);
                                                                                                                                                                    boolean jjtc002 = true;
                                                                                                                                                                    jjtree.openNodeScope(jjtn002);
          try {
                                                                                                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                                                    jjtc002 = false;
                                                                                                                       jjtn002.processToken(token);
          } finally {
                                                                                                                                                                    if (jjtc002) {
                                                                                                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                                                                    }
          }
          break;
        case StringLiteralForKindTest:
          jj_consume_token(StringLiteralForKindTest);
                                                                                                                                                                                                                                                  SimpleNode jjtn003 = new SimpleNode(this, JJTSTRINGLITERALFORKINDTEST);
                                                                                                                                                                                                                                                  boolean jjtc003 = true;
                                                                                                                                                                                                                                                  jjtree.openNodeScope(jjtn003);
          try {
                                                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                                                  jjtc003 = false;
                                                                                                                                                                                  jjtn003.processToken(token);
          } finally {
                                                                                                                                                                                                                                                  if (jjtc003) {
                                                                                                                                                                                                                                                    jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                                                  }
          }
          break;
        default:
          jj_la1[153] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[154] = jj_gen;
        ;
      }
      jj_consume_token(RparForKindTest);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void AttributeTest() throws ParseException {
 /*@bgen(jjtree) AttributeTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTATTRIBUTETEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AttributeType:
        jj_consume_token(AttributeType);
                    SimpleNode jjtn001 = new SimpleNode(this, JJTATTRIBUTETYPE);
                    boolean jjtc001 = true;
                    jjtree.openNodeScope(jjtn001);
        try {
                    jjtree.closeNodeScope(jjtn001,  true);
                    jjtc001 = false;
                   jjtn001.processToken(token);
        } finally {
                    if (jjtc001) {
                      jjtree.closeNodeScope(jjtn001,  true);
                    }
        }
        break;
      case AttributeTypeForKindTest:
        jj_consume_token(AttributeTypeForKindTest);
                                                                                                    SimpleNode jjtn002 = new SimpleNode(this, JJTATTRIBUTETYPEFORKINDTEST);
                                                                                                    boolean jjtc002 = true;
                                                                                                    jjtree.openNodeScope(jjtn002);
        try {
                                                                                                    jjtree.closeNodeScope(jjtn002,  true);
                                                                                                    jjtc002 = false;
                                                                              jjtn002.processToken(token);
        } finally {
                                                                                                    if (jjtc002) {
                                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                                    }
        }
        break;
      default:
        jj_la1[155] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AnyName:
      case QNameForItemType:
        AttribNameOrWildcard();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CommaForKindTest:
          jj_consume_token(CommaForKindTest);
                                                                                                                                                                                                                SimpleNode jjtn003 = new SimpleNode(this, JJTCOMMAFORKINDTEST);
                                                                                                                                                                                                                boolean jjtc003 = true;
                                                                                                                                                                                                                jjtree.openNodeScope(jjtn003);
          try {
                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                jjtc003 = false;
                                                                                                                                                          jjtn003.processToken(token);
          } finally {
                                                                                                                                                                                                                if (jjtc003) {
                                                                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                }
          }
          TypeName();
          break;
        default:
          jj_la1[156] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[157] = jj_gen;
        ;
      }
      jj_consume_token(RparForKindTest);
    } 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 AttribNameOrWildcard() throws ParseException {
 /*@bgen(jjtree) AttribNameOrWildcard */
  SimpleNode jjtn000 = new SimpleNode(this, JJTATTRIBNAMEORWILDCARD);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QNameForItemType:
        AttributeName();
        break;
      case AnyName:
        jj_consume_token(AnyName);
                                SimpleNode jjtn001 = new SimpleNode(this, JJTANYNAME);
                                boolean jjtc001 = true;
                                jjtree.openNodeScope(jjtn001);
        try {
                                jjtree.closeNodeScope(jjtn001,  true);
                                jjtc001 = false;
                               jjtn001.processToken(token);
        } finally {
                                if (jjtc001) {
                                  jjtree.closeNodeScope(jjtn001,  true);
                                }
        }
        break;
      default:
        jj_la1[158] = 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 SchemaAttributeTest() throws ParseException {
 /*@bgen(jjtree) SchemaAttributeTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSCHEMAATTRIBUTETEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SchemaAttributeType:
        jj_consume_token(SchemaAttributeType);
                          SimpleNode jjtn001 = new SimpleNode(this, JJTSCHEMAATTRIBUTETYPE);
                          boolean jjtc001 = true;
                          jjtree.openNodeScope(jjtn001);
        try {
                          jjtree.closeNodeScope(jjtn001,  true);
                          jjtc001 = false;
                         jjtn001.processToken(token);
        } finally {
                          if (jjtc001) {
                            jjtree.closeNodeScope(jjtn001,  true);
                          }
        }
        break;
      case SchemaAttributeTypeForKindTest:
        jj_consume_token(SchemaAttributeTypeForKindTest);
                                                                                                                      SimpleNode jjtn002 = new SimpleNode(this, JJTSCHEMAATTRIBUTETYPEFORKINDTEST);
                                                                                                                      boolean jjtc002 = true;
                                                                                                                      jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                      jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                      jjtc002 = false;
                                                                                          jjtn002.processToken(token);
        } finally {
                                                                                                                      if (jjtc002) {
                                                                                                                        jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                      }
        }
        break;
      default:
        jj_la1[159] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      AttributeDeclaration();
      jj_consume_token(RparForKindTest);
    } 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 AttributeDeclaration() throws ParseException {
 /*@bgen(jjtree) AttributeDeclaration */
  SimpleNode jjtn000 = new SimpleNode(this, JJTATTRIBUTEDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      AttributeName();
    } 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 ElementTest() throws ParseException {
 /*@bgen(jjtree) ElementTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTELEMENTTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ElementType:
        jj_consume_token(ElementType);
                  SimpleNode jjtn001 = new SimpleNode(this, JJTELEMENTTYPE);
                  boolean jjtc001 = true;
                  jjtree.openNodeScope(jjtn001);
        try {
                  jjtree.closeNodeScope(jjtn001,  true);
                  jjtc001 = false;
                 jjtn001.processToken(token);
        } finally {
                  if (jjtc001) {
                    jjtree.closeNodeScope(jjtn001,  true);
                  }
        }
        break;
      case ElementTypeForKindTest:
        jj_consume_token(ElementTypeForKindTest);
                                                                                              SimpleNode jjtn002 = new SimpleNode(this, JJTELEMENTTYPEFORKINDTEST);
                                                                                              boolean jjtc002 = true;
                                                                                              jjtree.openNodeScope(jjtn002);
        try {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                              jjtc002 = false;
                                                                          jjtn002.processToken(token);
        } finally {
                                                                                              if (jjtc002) {
                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                              }
        }
        break;
      case ElementTypeForDocumentTest:
        jj_consume_token(ElementTypeForDocumentTest);
                                                                                                                                                                                         SimpleNode jjtn003 = new SimpleNode(this, JJTELEMENTTYPEFORDOCUMENTTEST);
                                                                                                                                                                                         boolean jjtc003 = true;
                                                                                                                                                                                         jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                                         jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                         jjtc003 = false;
                                                                                                                                       jjtn003.processToken(token);
        } finally {
                                                                                                                                                                                         if (jjtc003) {
                                                                                                                                                                                           jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                         }
        }
        break;
      default:
        jj_la1[160] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AnyName:
      case QNameForItemType:
        ElementNameOrWildcard();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CommaForKindTest:
          jj_consume_token(CommaForKindTest);
                                                                                                                                                                                                                                                                                                        SimpleNode jjtn004 = new SimpleNode(this, JJTCOMMAFORKINDTEST);
                                                                                                                                                                                                                                                                                                        boolean jjtc004 = true;
                                                                                                                                                                                                                                                                                                        jjtree.openNodeScope(jjtn004);
          try {
                                                                                                                                                                                                                                                                                                        jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                                                        jjtc004 = false;
                                                                                                                                                                                                                    jjtn004.processToken(token);
          } finally {
                                                                                                                                                                                                                                                                                                        if (jjtc004) {
                                                                                                                                                                                                                                                                                                          jjtree.closeNodeScope(jjtn004,  true);
                                                                                                                                                                                                                                                                                                        }
          }
          TypeName();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Nillable:
            jj_consume_token(Nillable);
                                                                                                                                                                                                                                                                                                                                                                                     SimpleNode jjtn005 = new SimpleNode(this, JJTNILLABLE);
                                                                                                                                                                                                                                                                                                                                                                                     boolean jjtc005 = true;
                                                                                                                                                                                                                                                                                                                                                                                     jjtree.openNodeScope(jjtn005);
            try {
                                                                                                                                                                                                                                                                                                                                                                                     jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                                                                                     jjtc005 = false;
                                                                                                                                                                                                                                                                         jjtn005.processToken(token);
            } finally {
                                                                                                                                                                                                                                                                                                                                                                                     if (jjtc005) {
                                                                                                                                                                                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn005,  true);
                                                                                                                                                                                                                                                                                                                                                                                     }
            }
            break;
          default:
            jj_la1[161] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[162] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[163] = jj_gen;
        ;
      }
      jj_consume_token(RparForKindTest);
    } 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 ElementNameOrWildcard() throws ParseException {
 /*@bgen(jjtree) ElementNameOrWildcard */
  SimpleNode jjtn000 = new SimpleNode(this, JJTELEMENTNAMEORWILDCARD);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QNameForItemType:
        ElementName();
        break;
      case AnyName:
        jj_consume_token(AnyName);
                              SimpleNode jjtn001 = new SimpleNode(this, JJTANYNAME);
                              boolean jjtc001 = true;
                              jjtree.openNodeScope(jjtn001);
        try {
                              jjtree.closeNodeScope(jjtn001,  true);
                              jjtc001 = false;
                             jjtn001.processToken(token);
        } finally {
                              if (jjtc001) {
                                jjtree.closeNodeScope(jjtn001,  true);
                              }
        }
        break;
      default:
        jj_la1[164] = 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 SchemaElementTest() throws ParseException {
 /*@bgen(jjtree) SchemaElementTest */
  SimpleNode jjtn000 = new SimpleNode(this, JJTSCHEMAELEMENTTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SchemaElementType:
        jj_consume_token(SchemaElementType);
                        SimpleNode jjtn001 = new SimpleNode(this, JJTSCHEMAELEMENTTYPE);
                        boolean jjtc001 = true;
                        jjtree.openNodeScope(jjtn001);
        try {
                        jjtree.closeNodeScope(jjtn001,  true);
                        jjtc001 = false;
                       jjtn001.processToken(token);
        } finally {
                        if (jjtc001) {
                          jjtree.closeNodeScope(jjtn001,  true);
                        }
        }
        break;
      case SchemaElementTypeForKindTest:
        jj_consume_token(SchemaElementTypeForKindTest);
                                                                                                                SimpleNode jjtn002 = new SimpleNode(this, JJTSCHEMAELEMENTTYPEFORKINDTEST);
                                                                                                                boolean jjtc002 = true;
                                                                                                                jjtree.openNodeScope(jjtn002);
        try {
                                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                jjtc002 = false;
                                                                                      jjtn002.processToken(token);
        } finally {
                                                                                                                if (jjtc002) {
                                                                                                                  jjtree.closeNodeScope(jjtn002,  true);
                                                                                                                }
        }
        break;
      case SchemaElementTypeForDocumentTest:
        jj_consume_token(SchemaElementTypeForDocumentTest);
                                                                                                                                                                                                                       SimpleNode jjtn003 = new SimpleNode(this, JJTSCHEMAELEMENTTYPEFORDOCUMENTTEST);
                                                                                                                                                                                                                       boolean jjtc003 = true;
                                                                                                                                                                                                                       jjtree.openNodeScope(jjtn003);
        try {
                                                                                                                                                                                                                       jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                       jjtc003 = false;
                                                                                                                                                         jjtn003.processToken(token);
        } finally {
                                                                                                                                                                                                                       if (jjtc003) {
                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                                                       }
        }
        break;
      default:
        jj_la1[165] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      ElementDeclaration();
      jj_consume_token(RparForKindTest);
    } 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 ElementDeclaration() throws ParseException {
 /*@bgen(jjtree) ElementDeclaration */
  SimpleNode jjtn000 = new SimpleNode(this, JJTELEMENTDECLARATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ElementName();
    } 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 AttributeName() throws ParseException {
 /*@bgen(jjtree) AttributeName */
  SimpleNode jjtn000 = new SimpleNode(this, JJTATTRIBUTENAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QNameForItemType);
                      SimpleNode jjtn001 = new SimpleNode(this, JJTQNAMEFORITEMTYPE);
                      boolean jjtc001 = true;
                      jjtree.openNodeScope(jjtn001);
      try {
                      jjtree.closeNodeScope(jjtn001,  true);
                      jjtc001 = false;
                     jjtn001.processToken(token);
      } finally {
                      if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001,  true);
                      }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ElementName() throws ParseException {
 /*@bgen(jjtree) ElementName */
  SimpleNode jjtn000 = new SimpleNode(this, JJTELEMENTNAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QNameForItemType);
                      SimpleNode jjtn001 = new SimpleNode(this, JJTQNAMEFORITEMTYPE);
                      boolean jjtc001 = true;
                      jjtree.openNodeScope(jjtn001);
      try {
                      jjtree.closeNodeScope(jjtn001,  true);
                      jjtc001 = false;
                     jjtn001.processToken(token);
      } finally {
                      if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001,  true);
                      }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void TypeName() throws ParseException {
 /*@bgen(jjtree) TypeName */
  SimpleNode jjtn000 = new SimpleNode(this, JJTTYPENAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QNameForItemType);
                      SimpleNode jjtn001 = new SimpleNode(this, JJTQNAMEFORITEMTYPE);
                      boolean jjtc001 = true;
                      jjtree.openNodeScope(jjtn001);
      try {
                      jjtree.closeNodeScope(jjtn001,  true);
                      jjtc001 = false;
                     jjtn001.processToken(token);
      } finally {
                      if (jjtc001) {
                        jjtree.closeNodeScope(jjtn001,  true);
                      }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  public XPathTokenManager token_source;
  SimpleCharStream jj_input_stream;
  public Token token, jj_nt;
  private int jj_ntk;
  private int jj_gen;
  final private int[] jj_la1 = new int[166];
  static private int[] jj_la1_0;
  static private int[] jj_la1_1;
  static private int[] jj_la1_2;
  static private int[] jj_la1_3;
  static private int[] jj_la1_4;
  static private int[] jj_la1_5;
  static private int[] jj_la1_6;
  static private int[] jj_la1_7;
  static {
      jj_la1_0();
      jj_la1_1();
      jj_la1_2();
      jj_la1_3();
      jj_la1_4();
      jj_la1_5();
      jj_la1_6();
      jj_la1_7();
   }
   private static void jj_la1_0() {
      jj_la1_0 = new int[] {0x0,0xfffd885e,0x40,0xfffd881e,0x100,0x80000000,0x0,0x0,0x40000000,0x40000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3ffd801e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3ffd801e,0x0,0x0,0x0,0x0,0x3ffd801e,0x3ffd801e,0x0,0x0,0x3ffd801e,0x3ffc0000,0xaec0000,0xaec0000,0x0,0x35100000,0x35100000,0x0,0x0,0x0,0x0,0x1801e,0x1e,0xe,0x3ffd801e,0x0,0x3ffd801e,0x18000,0x18000,0x0,0x18000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18000,0x0,0x0,0x0,0x0,0x18000,0x0,0x0,0x0,0x0,0x0,0x0,0x3ffd801e,0x0,0x3ffd801e,0x0,0x3ffd801e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x20,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
   }
   private static void jj_la1_1() {
      jj_la1_1 = new int[] {0x0,0x3042000c,0x0,0x3042000c,0x0,0x3040000c,0x0,0x0,0x0,0x0,0x3040000c,0x0,0xc0000000,0x0,0x3,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20000,0x0,0x40,0x0,0x0,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x20000,0x80,0x100,0x0,0x0,0x0,0x0,0x0,0x1e00,0x1e00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,};
   }
   private static void jj_la1_2() {
      jj_la1_2 = new int[] {0x0,0xdfffc002,0x0,0xdfffc002,0x0,0x10000000,0xc0000002,0xc0000002,0x0,0x0,0x10000000,0x0,0x0,0xc0000000,0x0,0x0,0x0,0x20000001,0x0,0x0,0x20000001,0x1,0x0,0x0,0x100,0x0,0x0,0x100,0x0,0x0,0x100,0x0,0x0,0xfffc000,0x0,0x0,0x8,0x0,0x100,0x200,0x0,0x100,0x200,0x100,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x100,0x0,0x100,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x40,0x40,0xa0,0xa0,0x800,0x0,0x1000,0x0,0x0,0x0,0xfffc000,0x0,0x0,0x0,0x0,0xfffc000,0xfffc000,0x0,0x0,0xfffc000,0x3c000,0x3c000,0x0,0x0,0x0,0x0,0x3c000,0x0,0x0,0x0,0xffc0000,0x0,0x0,0xfffc000,0x0,0xfffc000,0xff00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff00000,0x2100000,0xfffc000,0x4200000,0xfffc000,0xc00000,0xfffc000,0x0,0x0,0x3e000,0x0,0x3e000,0x0,0x3c000,0x0,0x0,0x14000,0x14000,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x20000,0x4000,0x0,0x0,0x0,0x0,0x10000,};
   }
   private static void jj_la1_3() {
      jj_la1_3 = new int[] {0x0,0x7a6,0x0,0x7a6,0x0,0x0,0x6,0x6,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x37ffa000,0x37ffa000,0x0,0xc0000000,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7a0,0x300b2000,0x7e00000,0x148000,0x0,0x1a0,0x7a0,0x1800,0x1800,0x1a0,0x1a0,0x1a0,0x0,0x0,0x0,0x0,0x1a0,0x1a0,0x1a0,0x0,0x0,0x0,0x0,0x7a0,0x0,0x7a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7a0,0x0,0x7a0,0x0,0x7a0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x40,0x40,0x0,};
   }
   private static void jj_la1_4() {
      jj_la1_4 = new int[] {0x0,0xffecf0c3,0x0,0xffecf0c3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffecf0c3,0xc000,0xc000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x20,0x0,0x0,0x0,0x20000,0x0,0x10000,0x3,0x3,0xffec00c0,0x0,0x0,0x0,0xc0000,0xffe000c0,0xffe000c0,0x0,0x0,0xffe000c0,0xff600080,0xff600080,0x0,0x80,0x0,0x0,0xff600000,0x0,0x0,0x100,0x800040,0x0,0x0,0xffecf0c3,0x0,0xffecf0c3,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0xffecf0c3,0x0,0xffecf0c3,0x0,0xffecf0c3,0x4,0x1c,0xff600000,0x1c,0xff600000,0x0,0xff600000,0x1000000,0x600000,0xb0000000,0xb0000000,0x4000000,0x2000000,0x8000000,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x0,0x0,0x80000000,};
   }
   private static void jj_la1_5() {
      jj_la1_5 = new int[] {0x800,0x840c0ff,0x0,0x840c0ff,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x300000,0x0,0x0,0x100,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x100,0x800c0ff,0x0,0x0,0x0,0x30000,0x0,0x0,0x100,0x0,0x0,0x0,0x100,0x0,0x30000,0x100,0xc0000,0xc0000,0x300000,0x300000,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800c03f,0x0,0x0,0x0,0x0,0x800c03f,0x800c03f,0x0,0x0,0x800c03f,0x803f,0x3f,0x0,0x0,0x8000,0x0,0x3f,0x0,0x0,0x0,0x8004000,0x0,0x0,0x800c0ff,0x100,0x800c0ff,0x0,0x0,0x0,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0000000,0x0,0x0,0x0,0x800c0ff,0x0,0x800c0ff,0x0,0x800c0ff,0x0,0x0,0x180003f,0x0,0x180003f,0x1800000,0x3f,0x20,0x0,0x1,0x1,0x8,0x10,0x4,0x20000000,0x20000000,0x0,0x200,0x2000000,0x2000000,0x2,0x0,0x0,0x200,0x2000000,0x2000000,0x1,};
   }
   private static void jj_la1_6() {
      jj_la1_6 = new int[] {0x0,0x30,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3000,0x0,0x0,0x3000,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x30,0x30,0x0,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x0,0x30,0x0,0x30,0x30,0x30,0x30,0x4f036,0x0,0xc0,0x0,0x0,0x0,0x800,0x9f006,0x9f006,0x12f006,0x12f006,0x2000000,0x8f006,0x10f006,0x4f036,0xf006,0x0,0x600000,0x600000,0x0,0x0,0x800000,0x0,0x1000000,0x0,0x0,0x30,0x0,0x30,0x0,0x30,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
   }
   private static void jj_la1_7() {
      jj_la1_7 = new int[] {0x0,0xb00,0x0,0xb00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xb00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xb00,0x0,0x0,0x0,0x0,0xb00,0xb00,0x0,0x0,0xb00,0x800,0x800,0x0,0x0,0x0,0x0,0x800,0x800,0x0,0x0,0x300,0x0,0x0,0xb00,0x0,0xb00,0x300,0x300,0x0,0x300,0x2000,0x0,0x2000,0x2000,0x2000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x300,0x0,0x300,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0xb00,0x0,0xb00,0x0,0xb00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
   }

  public XPath(java.io.InputStream stream) {
     this(stream, null);
  }
  public XPath(java.io.InputStream stream, String encoding) {
    try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source = new XPathTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 166; i++) jj_la1[i] = -1;
  }

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

  public XPath(java.io.Reader stream) {
    jj_input_stream = new SimpleCharStream(stream, 1, 1);
    token_source = new XPathTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 166; i++) jj_la1[i] = -1;
  }

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

  public XPath(XPathTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 166; i++) jj_la1[i] = -1;
  }

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

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

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

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

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

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

  public ParseException generateParseException() {
    jj_expentries.removeAllElements();
    boolean[] la1tokens = new boolean[251];
    for (int i = 0; i < 251; i++) {
      la1tokens[i] = false;
    }
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 166; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
          if ((jj_la1_3[i] & (1<<j)) != 0) {
            la1tokens[96+j] = true;
          }
          if ((jj_la1_4[i] & (1<<j)) != 0) {
            la1tokens[128+j] = true;
          }
          if ((jj_la1_5[i] & (1<<j)) != 0) {
            la1tokens[160+j] = true;
          }
          if ((jj_la1_6[i] & (1<<j)) != 0) {
            la1tokens[192+j] = true;
          }
          if ((jj_la1_7[i] & (1<<j)) != 0) {
            la1tokens[224+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 251; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.addElement(jj_expentry);
      }
    }
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = (int[])jj_expentries.elementAt(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  final public void enable_tracing() {
  }

  final public void disable_tracing() {
  }

                }
