/* Generated By:JJTree&JavaCC: Do not edit this line. XPath.java */
package org.apache.xpath.impl.parser;


import java.util.Stack;

public class XPath/*@bgen(jjtree)*/implements XPathTreeConstants, XPathConstants {/*@bgen(jjtree)*/
  protected JJTXPathState jjtree = new JJTXPathState();
    // Begin generated by etree.xsl:extra-parser-code 

    int m_predLevel = 0;

    /**
     * Node factory for customized parser.  
     */
    private NodeFactory m_nodeFactory;

    /**
     * Returns the node factory.  
     * @return NodeFactory
     */
    public NodeFactory getNodeFactory() {
        if (m_nodeFactory == null)
        {
                m_nodeFactory = DefaultNodeFactory.createNodeFactory();
        }
        return m_nodeFactory;
    }


    /**
     * The "version" property as pertains to the XPath spec.
     * @serial
     */
    private double m_version;

    /**
     * Set the "version" property for XPath.
     *
     * @param v Value for the "version" property.
     */
    public void setVersion(double v)
    {
        m_version = v;
    }

    /**
     * Get the "version" property for XPath.
     *
     * @return The value of the "version" property.
     */
    public double getVersion()
    {
        return m_version;
    }
    // end generated by etree.xsl:extra-parser-code 


      boolean m_isMatchPattern = 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
                        {
                                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.MatchPattern();
          }
          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.MatchPattern();
          }
          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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTXPATH2);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      XPath();
      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 SimpleNode MatchPattern() throws ParseException {
                 /*@bgen(jjtree) MatchPattern */
                 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTMATCHPATTERN);
                 boolean jjtc000 = true;
                 jjtree.openNodeScope(jjtn000);m_isMatchPattern = true;
    try {
      Pattern();
      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 XPath() throws ParseException {
 /*@bgen(jjtree) XPath */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTXPATH);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisNamespace:
      case AxisAncestorOrSelf:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Root:
      case RootDescendants:
      case Minus:
      case Plus:
      case Lpar:
      case At:
      case Some:
      case Every:
      case ForVariable:
      case CastAs:
      case TreatAs:
      case ValidateLbrace:
      case ValidateContext:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case IfLpar:
      case Dot:
      case DotDot:
      case VariableIndicator:
      case QName:
      case QNameLpar:
        ExprSequence();
        break;
      default:
        jj_la1[0] = 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 ExprSequence() throws ParseException {
 /*@bgen(jjtree) ExprSequence */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEXPRSEQUENCE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Expr();
      label_1:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Comma:
          ;
          break;
        default:
          jj_la1[1] = jj_gen;
          break label_1;
        }
        jj_consume_token(Comma);
        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 Pattern() throws ParseException {
 /*@bgen(jjtree) Pattern */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPATTERN);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      PathPattern();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Union:
      case Vbar:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Union:
          jj_consume_token(Union);
          break;
        case Vbar:
          jj_consume_token(Vbar);
          break;
        default:
          jj_la1[2] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        Pattern();
        break;
      default:
        jj_la1[3] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void PathPattern() throws ParseException {
 /*@bgen(jjtree) PathPattern */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPATHPATTERN);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Root:
        jj_consume_token(Root);
            SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 AxisChild:
        case AxisAttribute:
        case Star:
        case NCNameColonStar:
        case StarColonNCName:
        case At:
        case NodeLpar:
        case CommentLpar:
        case TextLpar:
        case ProcessingInstructionLpar:
        case QName:
          RelativePathPattern();
          break;
        default:
          jj_la1[4] = jj_gen;
          ;
        }
        break;
      case RootDescendants:
        jj_consume_token(RootDescendants);
                                                                                                    SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                    }
        }
        RelativePathPattern();
        break;
      case QNameLpar:
        IdKeyPattern();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Slash:
        case SlashSlash:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Slash:
            jj_consume_token(Slash);
            break;
          case SlashSlash:
            jj_consume_token(SlashSlash);
                                                                                                                                                                                                                           SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASHSLASH);
                                                                                                                                                                                                                           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[5] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          RelativePathPattern();
          break;
        default:
          jj_la1[6] = jj_gen;
          ;
        }
        break;
      case AxisChild:
      case AxisAttribute:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case At:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case QName:
        RelativePathPattern();
        break;
      default:
        jj_la1[7] = 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 RelativePathPattern() throws ParseException {
    PatternStep();
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Slash:
    case SlashSlash:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Slash:
        jj_consume_token(Slash);
        break;
      case SlashSlash:
        jj_consume_token(SlashSlash);
                                          SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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[8] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      RelativePathPattern();
      break;
    default:
      jj_la1[9] = jj_gen;
      ;
    }
  }

  final public void PatternStep() throws ParseException {
 /*@bgen(jjtree) PatternStep */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPATTERNSTEP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AxisChild:
      case AxisAttribute:
      case At:
        PatternAxis();
        break;
      default:
        jj_la1[10] = jj_gen;
        ;
      }
      NodeTest();
      Predicates();
    } 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 PatternAxis() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case AxisChild:
      jj_consume_token(AxisChild);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 AxisAttribute:
      jj_consume_token(AxisAttribute);
                                                                                 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAXISATTRIBUTE);
                                                                                 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 At:
      jj_consume_token(At);
                                                                                                                                           SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAT);
                                                                                                                                           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[11] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void IdKeyPattern() throws ParseException {
 /*@bgen(jjtree) IdKeyPattern */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIDKEYPATTERN);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QNameLpar);
               SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
               }
      }
      IdKeyValue();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Comma:
        jj_consume_token(Comma);
        IdKeyValue();
        break;
      default:
        jj_la1[12] = 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 IdKeyValue() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case StringLiteral:
      jj_consume_token(StringLiteral);
                    SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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;
    case VariableIndicator:
      jj_consume_token(VariableIndicator);
      jj_consume_token(VarName);
                                                                                                        SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(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[13] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void Expr() throws ParseException {
    OrExpr();
  }

  final public void OrExpr() throws ParseException {
 /*@bgen(jjtree) #OrExpr(> 1) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTOREXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      AndExpr();
      label_2:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Or:
          ;
          break;
        default:
          jj_la1[14] = jj_gen;
          break label_2;
        }
        jj_consume_token(Or);
          binaryTokenStack.push(token);
        AndExpr();
                  SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTANDEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      FLWRExpr();
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case And:
          ;
          break;
        default:
          jj_la1[15] = jj_gen;
          break label_3;
        }
        jj_consume_token(And);
          binaryTokenStack.push(token);
        FLWRExpr();
                  SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 FLWRExpr() throws ParseException {
 /*@bgen(jjtree) #FLWRExpr(> 1) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFLWREXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_4:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ForVariable:
          ;
          break;
        default:
          jj_la1[16] = jj_gen;
          break label_4;
        }
        SimpleForClause();
        jj_consume_token(Return);
                               SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRETURN);
                               boolean jjtc001 = true;
                               jjtree.openNodeScope(jjtn001);
        try {
                               jjtree.closeNodeScope(jjtn001,  true);
                               jjtc001 = false;
                              jjtn001.processToken(token);
        } finally {
                               if (jjtc001) {
                                 jjtree.closeNodeScope(jjtn001,  true);
                               }
        }
      }
      QuantifiedExpr();
    } 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 QuantifiedExpr() throws ParseException {
 /*@bgen(jjtree) #QuantifiedExpr(> 1) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTQUANTIFIEDEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_5:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Some:
        case Every:
          ;
          break;
        default:
          jj_la1[17] = jj_gen;
          break label_5;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Some:
          jj_consume_token(Some);
            SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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[18] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jj_consume_token(VarName);
                                                                                                                      SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                                      }
        }
        jj_consume_token(In);
                                                                                                                                                                         SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                                                                                         }
        }
        Expr();
        label_6:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Comma:
            ;
            break;
          default:
            jj_la1[19] = jj_gen;
            break label_6;
          }
          jj_consume_token(Comma);
          jj_consume_token(VariableIndicator);
          jj_consume_token(VarName);
                                                                                                                                                                                                                                                                SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                                                                                                                                                                                }
          }
          jj_consume_token(In);
                                                                                                                                                                                                                                                                                                                    SimpleNode jjtn006 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                                                                                                                                                                                                                                    }
          }
          Expr();
        }
        jj_consume_token(Satisfies);
                                                                                                                                                                                                                                                                                                                                                                                 SimpleNode jjtn007 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                                                                                                                                                                                                                                                                                                 }
        }
      }
      IfExpr();
    } 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 IfExpr() throws ParseException {
 /*@bgen(jjtree) #IfExpr(> 1) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIFEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_7:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IfLpar:
          ;
          break;
        default:
          jj_la1[20] = jj_gen;
          break label_7;
        }
        jj_consume_token(IfLpar);
        Expr();
        jj_consume_token(Rpar);
        jj_consume_token(Then);
        Expr();
        jj_consume_token(Else);
      }
      InstanceofExpr();
    } 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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTINSTANCEOFEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      CastableExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Instanceof:
        jj_consume_token(Instanceof);
        SequenceType();
        break;
      default:
        jj_la1[21] = 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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCASTABLEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ComparisonExpr();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Castable:
        jj_consume_token(Castable);
        SingleType();
        break;
      default:
        jj_la1[22] = 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 ComparisonExpr() throws ParseException {
 /*@bgen(jjtree) #ComparisonExpr(> 1) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCOMPARISONEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      RangeExpr();
      label_8:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Equals:
        case Is:
        case NotEquals:
        case IsNot:
        case LtEquals:
        case LtLt:
        case GtEquals:
        case GtGt:
        case FortranEq:
        case FortranNe:
        case FortranGt:
        case FortranGe:
        case FortranLt:
        case FortranLe:
        case Lt:
        case Gt:
          ;
          break;
        default:
          jj_la1[23] = jj_gen;
          break label_8;
        }
        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 IsNot:
          NodeComp();
          break;
        case LtLt:
        case GtGt:
          OrderComp();
          break;
        default:
          jj_la1[24] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        RangeExpr();
                  SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
                  }
        }
      }
    } 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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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[25] = 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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTADDITIVEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      MultiplicativeExpr();
      label_9:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Minus:
        case Plus:
          ;
          break;
        default:
          jj_la1[26] = jj_gen;
          break label_9;
        }
        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[27] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        MultiplicativeExpr();
                  SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTMULTIPLICATIVEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      UnaryExpr();
      label_10:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Div:
        case Idiv:
        case Mod:
        case Multiply:
          ;
          break;
        default:
          jj_la1[28] = jj_gen;
          break label_10;
        }
        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[29] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        UnaryExpr();
                  SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 UnaryExpr() throws ParseException {
 /*@bgen(jjtree) #UnaryExpr( keepUnary) */
 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTUNARYEXPR);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);boolean keepUnary=false;
    try {
      label_11:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Minus:
        case Plus:
          ;
          break;
        default:
          jj_la1[30] = jj_gen;
          break label_11;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Minus:
          jj_consume_token(Minus);
            SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTMINUS);
            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 Plus:
          jj_consume_token(Plus);
                                                                               SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPLUS);
                                                                               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[31] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      UnionExpr();
    } 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 UnionExpr() throws ParseException {
 /*@bgen(jjtree) #UnionExpr(> 1) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTUNIONEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      IntersectExceptExpr();
      label_12:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Union:
        case Vbar:
          ;
          break;
        default:
          jj_la1[32] = jj_gen;
          break label_12;
        }
        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[33] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        IntersectExceptExpr();
                  SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(this, JJTINTERSECTEXCEPTEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ValueExpr();
      label_13:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Intersect:
        case Except:
          ;
          break;
        default:
          jj_la1[34] = jj_gen;
          break label_13;
        }
        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[35] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        ValueExpr();
                  SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 ValueExpr() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ValidateLbrace:
    case ValidateContext:
      ValidateExpr();
      break;
    case CastAs:
      CastExpr();
      break;
    case TreatAs:
      TreatExpr();
      break;
    case IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case StringLiteral:
    case AxisChild:
    case AxisDescendant:
    case AxisParent:
    case AxisAttribute:
    case AxisSelf:
    case AxisDescendantOrSelf:
    case AxisAncestor:
    case AxisFollowingSibling:
    case AxisPrecedingSibling:
    case AxisFollowing:
    case AxisPreceding:
    case AxisNamespace:
    case AxisAncestorOrSelf:
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case Root:
    case RootDescendants:
    case Lpar:
    case At:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case Dot:
    case DotDot:
    case VariableIndicator:
    case QName:
    case QNameLpar:
      PathExpr();
      break;
    default:
      jj_la1[36] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void PathExpr() throws ParseException {
 /*@bgen(jjtree) #PathExpr(> 0) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 AxisChild:
        case AxisDescendant:
        case AxisParent:
        case AxisAttribute:
        case AxisSelf:
        case AxisDescendantOrSelf:
        case AxisAncestor:
        case AxisFollowingSibling:
        case AxisPrecedingSibling:
        case AxisFollowing:
        case AxisPreceding:
        case AxisNamespace:
        case AxisAncestorOrSelf:
        case Star:
        case NCNameColonStar:
        case StarColonNCName:
        case Lpar:
        case At:
        case NodeLpar:
        case CommentLpar:
        case TextLpar:
        case ProcessingInstructionLpar:
        case Dot:
        case DotDot:
        case VariableIndicator:
        case QName:
        case QNameLpar:
          RelativePathExpr();
          break;
        default:
          jj_la1[37] = jj_gen;
          ;
        }
        break;
      case RootDescendants:
        jj_consume_token(RootDescendants);
                                                                                                 SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(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 AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisNamespace:
      case AxisAncestorOrSelf:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Lpar:
      case At:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case Dot:
      case DotDot:
      case VariableIndicator:
      case QName:
      case QNameLpar:
        RelativePathExpr();
        break;
      default:
        jj_la1[38] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 0);
    }
    }
  }

  final public void RelativePathExpr() throws ParseException {
    StepExpr();
    label_14:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Slash:
      case SlashSlash:
        ;
        break;
      default:
        jj_la1[39] = jj_gen;
        break label_14;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Slash:
        jj_consume_token(Slash);
        break;
      case SlashSlash:
        jj_consume_token(SlashSlash);
                                       SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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[40] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      StepExpr();
    }
  }

  final public void StepExpr() throws ParseException {
 /*@bgen(jjtree) #StepExpr(> 1 || isStep) */
 SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTEPEXPR);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);boolean isStep=false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AxisChild:
      case AxisDescendant:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisFollowingSibling:
      case AxisFollowing:
      case AxisNamespace:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case At:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case Dot:
      case QName:
        ForwardStep();
                 isStep=true;
        break;
      case AxisParent:
      case AxisAncestor:
      case AxisPrecedingSibling:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case DotDot:
        ReverseStep();
                                               isStep=true;
        break;
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case Lpar:
      case VariableIndicator:
      case QNameLpar:
        PrimaryExpr();
        break;
      default:
        jj_la1[41] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      Predicates();
    } 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 SimpleForClause() throws ParseException {
    jj_consume_token(ForVariable);
    jj_consume_token(VarName);
                           SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
                           }
    }
    jj_consume_token(In);
                                                                             SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                             }
    }
    Expr();
    label_15:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Comma:
        ;
        break;
      default:
        jj_la1[42] = jj_gen;
        break label_15;
      }
      jj_consume_token(Comma);
      jj_consume_token(VariableIndicator);
      jj_consume_token(VarName);
                                                                                                                                                                    SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                                                                                    }
      }
      jj_consume_token(In);
                                                                                                                                                                                                                       SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                                                                                                                                                                       }
      }
      Expr();
    }
  }

  final public void ValidateExpr() throws ParseException {
 /*@bgen(jjtree) ValidateExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 ValidateContext:
        jj_consume_token(ValidateContext);
                                                                                              SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTVALIDATECONTEXT);
                                                                                              boolean jjtc002 = true;
                                                                                              jjtree.openNodeScope(jjtn002);
        try {
                                                                                              jjtree.closeNodeScope(jjtn002,  true);
                                                                                              jjtc002 = false;
                                                                       jjtn002.processToken(token);
        } finally {
                                                                                              if (jjtc002) {
                                                                                                jjtree.closeNodeScope(jjtn002,  true);
                                                                                              }
        }
        SchemaGlobalContext();
        label_16:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Slash:
            ;
            break;
          default:
            jj_la1[43] = jj_gen;
            break label_16;
          }
          jj_consume_token(Slash);
                                                                                                                                                                                  SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASH);
                                                                                                                                                                                  boolean jjtc003 = true;
                                                                                                                                                                                  jjtree.openNodeScope(jjtn003);
          try {
                                                                                                                                                                                  jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                  jjtc003 = false;
                                                                                                                                    jjtn003.processToken(token);
          } finally {
                                                                                                                                                                                  if (jjtc003) {
                                                                                                                                                                                    jjtree.closeNodeScope(jjtn003,  true);
                                                                                                                                                                                  }
          }
          SchemaContextStep();
        }
        jj_consume_token(LbraceExprEnclosure);
                                                                                                                                                                                                                                                                         SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(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[44] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      Expr();
      jj_consume_token(Rbrace);
                                                                                                                                                                                                                                                                                                                                                    SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(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 CastExpr() throws ParseException {
 /*@bgen(jjtree) CastExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCASTEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(CastAs);
      SingleType();
      ParenthesizedExpr();
    } 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 TreatExpr() throws ParseException {
 /*@bgen(jjtree) TreatExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTREATEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(TreatAs);
      SequenceType();
      ParenthesizedExpr();
    } 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 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[45] = 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[46] = 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 IsNot:
      jj_consume_token(IsNot);
          binaryTokenStack.push(token);
      break;
    default:
      jj_la1[47] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

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

  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 QNameLpar:
      FunctionCall();
      break;
    case VariableIndicator:
      jj_consume_token(VariableIndicator);
      jj_consume_token(VarName);
                                                                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
                                                                }
      }
      break;
    case Lpar:
      ParenthesizedExpr();
      break;
    default:
      jj_la1[49] = 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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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;
    case AxisNamespace:
      jj_consume_token(AxisNamespace);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   SimpleNode jjtn008 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAXISNAMESPACE);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   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[50] = 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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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[51] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void NodeTest() throws ParseException {
 /*@bgen(jjtree) NodeTest */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNODETEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
        KindTest();
        break;
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case QName:
        NameTest();
        break;
      default:
        jj_la1[52] = 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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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[53] = 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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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[54] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void KindTest() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ProcessingInstructionLpar:
      ProcessingInstructionTest();
      break;
    case CommentLpar:
      CommentTest();
      break;
    case TextLpar:
      TextTest();
      break;
    case NodeLpar:
      AnyKindTest();
      break;
    default:
      jj_la1[55] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ProcessingInstructionTest() throws ParseException {
 /*@bgen(jjtree) ProcessingInstructionTest */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPROCESSINGINSTRUCTIONTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(ProcessingInstructionLpar);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case StringLiteral:
        jj_consume_token(StringLiteral);
                                                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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[56] = jj_gen;
        ;
      }
      jj_consume_token(Rpar);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void CommentTest() throws ParseException {
 /*@bgen(jjtree) CommentTest */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCOMMENTTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(CommentLpar);
      jj_consume_token(Rpar);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void TextTest() throws ParseException {
 /*@bgen(jjtree) TextTest */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTEXTTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(TextLpar);
      jj_consume_token(Rpar);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void AnyKindTest() throws ParseException {
 /*@bgen(jjtree) AnyKindTest */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTANYKINDTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(NodeLpar);
      jj_consume_token(Rpar);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  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:
    case AxisNamespace:
      ForwardAxis();
      NodeTest();
      break;
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case At:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case Dot:
    case QName:
      AbbreviatedForwardStep();
      break;
    default:
      jj_la1[57] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  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:
      AbbreviatedReverseStep();
      break;
    default:
      jj_la1[58] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void AbbreviatedForwardStep() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Dot:
      jj_consume_token(Dot);
          SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
          }
      }
      break;
    case At:
      jj_consume_token(At);
                                                           SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTAT);
                                                           boolean jjtc002 = true;
                                                           jjtree.openNodeScope(jjtn002);
      try {
                                                           jjtree.closeNodeScope(jjtn002,  true);
                                                           jjtc002 = false;
                                               jjtn002.processToken(token);
      } finally {
                                                           if (jjtc002) {
                                                             jjtree.closeNodeScope(jjtn002,  true);
                                                           }
      }
      NameTest();
      break;
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case QName:
      NodeTest();
      break;
    default:
      jj_la1[59] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void AbbreviatedReverseStep() throws ParseException {
    jj_consume_token(DotDot);
            SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 Predicates() throws ParseException {
 /*@bgen(jjtree) #Predicates(> 0) */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPREDICATES);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_17:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Lbrack:
          ;
          break;
        default:
          jj_la1[60] = jj_gen;
          break label_17;
        }
        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 NumericLiteral() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case IntegerLiteral:
      jj_consume_token(IntegerLiteral);
                     SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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 = (SimpleNode)SimpleNode.jjtCreate(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[61] = 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 = (SimpleNode)SimpleNode.jjtCreate(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[62] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  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 AxisChild:
    case AxisDescendant:
    case AxisParent:
    case AxisAttribute:
    case AxisSelf:
    case AxisDescendantOrSelf:
    case AxisAncestor:
    case AxisFollowingSibling:
    case AxisPrecedingSibling:
    case AxisFollowing:
    case AxisPreceding:
    case AxisNamespace:
    case AxisAncestorOrSelf:
    case Star:
    case NCNameColonStar:
    case StarColonNCName:
    case Root:
    case RootDescendants:
    case Minus:
    case Plus:
    case Lpar:
    case At:
    case Some:
    case Every:
    case ForVariable:
    case CastAs:
    case TreatAs:
    case ValidateLbrace:
    case ValidateContext:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case IfLpar:
    case Dot:
    case DotDot:
    case VariableIndicator:
    case QName:
    case QNameLpar:
      ExprSequence();
      break;
    default:
      jj_la1[63] = jj_gen;
      ;
    }
    jj_consume_token(Rpar);
  }

  final public void FunctionCall() throws ParseException {
 /*@bgen(jjtree) FunctionCall */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFUNCTIONCALL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QNameLpar);
               SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 AxisChild:
      case AxisDescendant:
      case AxisParent:
      case AxisAttribute:
      case AxisSelf:
      case AxisDescendantOrSelf:
      case AxisAncestor:
      case AxisFollowingSibling:
      case AxisPrecedingSibling:
      case AxisFollowing:
      case AxisPreceding:
      case AxisNamespace:
      case AxisAncestorOrSelf:
      case Star:
      case NCNameColonStar:
      case StarColonNCName:
      case Root:
      case RootDescendants:
      case Minus:
      case Plus:
      case Lpar:
      case At:
      case Some:
      case Every:
      case ForVariable:
      case CastAs:
      case TreatAs:
      case ValidateLbrace:
      case ValidateContext:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case IfLpar:
      case Dot:
      case DotDot:
      case VariableIndicator:
      case QName:
      case QNameLpar:
        Expr();
        label_18:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Comma:
            ;
            break;
          default:
            jj_la1[64] = jj_gen;
            break label_18;
          }
          jj_consume_token(Comma);
          Expr();
        }
        break;
      default:
        jj_la1[65] = 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 SchemaContext() throws ParseException {
 /*@bgen(jjtree) SchemaContext */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSCHEMACONTEXT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(InContext);
               SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTINCONTEXT);
               boolean jjtc001 = true;
               jjtree.openNodeScope(jjtn001);
      try {
               jjtree.closeNodeScope(jjtn001,  true);
               jjtc001 = false;
              jjtn001.processToken(token);
      } finally {
               if (jjtc001) {
                 jjtree.closeNodeScope(jjtn001,  true);
               }
      }
      SchemaGlobalContext();
      label_19:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Slash:
          ;
          break;
        default:
          jj_la1[66] = jj_gen;
          break label_19;
        }
        jj_consume_token(Slash);
                                                                                             SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASH);
                                                                                             boolean jjtc002 = true;
                                                                                             jjtree.openNodeScope(jjtn002);
        try {
                                                                                             jjtree.closeNodeScope(jjtn002,  true);
                                                                                             jjtc002 = false;
                                                                           jjtn002.processToken(token);
        } finally {
                                                                                             if (jjtc002) {
                                                                                               jjtree.closeNodeScope(jjtn002,  true);
                                                                                             }
        }
        SchemaContextStep();
      }
    } 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 SchemaGlobalContext() throws ParseException {
 /*@bgen(jjtree) SchemaGlobalContext */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSCHEMAGLOBALCONTEXT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QName:
        jj_consume_token(QName);
            SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 TypeQName:
        jj_consume_token(TypeQName);
                                                                     SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTYPEQNAME);
                                                                     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[67] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void SchemaContextStep() throws ParseException {
 /*@bgen(jjtree) SchemaContextStep */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSCHEMACONTEXTSTEP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QName);
           SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
           }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void SingleType() throws ParseException {
 /*@bgen(jjtree) SingleType */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSINGLETYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      AtomicType();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QMark:
        jj_consume_token(QMark);
                         SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTQMARK);
                         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[68] = 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 SequenceType() throws ParseException {
 /*@bgen(jjtree) SequenceType */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSEQUENCETYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Item:
      case ElementType:
      case AttributeType:
      case AtomicValue:
      case Node:
      case Comment:
      case Document:
      case Text:
      case Untyped:
      case ProcessingInstruction:
      case QName:
        ItemType();
        OccurrenceIndicator();
        break;
      case Empty:
        jj_consume_token(Empty);
                                                 SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTEMPTY);
                                                 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[69] = 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 ItemType() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case ElementType:
    case AttributeType:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ElementType:
        jj_consume_token(ElementType);
                    SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 AttributeType:
        jj_consume_token(AttributeType);
                                                                                       SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTATTRIBUTETYPE);
                                                                                       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[70] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OfType:
      case QName:
        ElemOrAttrType();
        break;
      default:
        jj_la1[71] = jj_gen;
        ;
      }
      break;
    case Node:
      jj_consume_token(Node);
                                                                                                                                                                        SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTNODE);
                                                                                                                                                                        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 ProcessingInstruction:
      jj_consume_token(ProcessingInstruction);
                                                                                                                                                                                                                                            SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPROCESSINGINSTRUCTION);
                                                                                                                                                                                                                                            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 Comment:
      jj_consume_token(Comment);
                                                                                                                                                                                                                                                                                                                   SimpleNode jjtn005 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCOMMENT);
                                                                                                                                                                                                                                                                                                                   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 Text:
      jj_consume_token(Text);
                                                                                                                                                                                                                                                                                                                                                                         SimpleNode jjtn006 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTEXT);
                                                                                                                                                                                                                                                                                                                                                                         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 Document:
      jj_consume_token(Document);
                                                                                                                                                                                                                                                                                                                                                                                                                                 SimpleNode jjtn007 = (SimpleNode)SimpleNode.jjtCreate(this, JJTDOCUMENT);
                                                                                                                                                                                                                                                                                                                                                                                                                                 boolean jjtc007 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                 jjtree.openNodeScope(jjtn007);
      try {
                                                                                                                                                                                                                                                                                                                                                                                                                                 jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                 jjtc007 = false;
                                                                                                                                                                                                                                                                                                                    jjtn007.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                 if (jjtc007) {
                                                                                                                                                                                                                                                                                                                                                                                                                                   jjtree.closeNodeScope(jjtn007,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                 }
      }
      break;
    case Item:
      jj_consume_token(Item);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         SimpleNode jjtn008 = (SimpleNode)SimpleNode.jjtCreate(this, JJTITEM);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         boolean jjtc008 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         jjtree.openNodeScope(jjtn008);
      try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         jjtree.closeNodeScope(jjtn008,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         jjtc008 = false;
                                                                                                                                                                                                                                                                                                                                                            jjtn008.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         if (jjtc008) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           jjtree.closeNodeScope(jjtn008,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
      }
      break;
    case QName:
      AtomicType();
      break;
    case Untyped:
      jj_consume_token(Untyped);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SimpleNode jjtn009 = (SimpleNode)SimpleNode.jjtCreate(this, JJTUNTYPED);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              boolean jjtc009 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jjtree.openNodeScope(jjtn009);
      try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jjtree.closeNodeScope(jjtn009,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jjtc009 = false;
                                                                                                                                                                                                                                                                                                                                                                                                                     jjtn009.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              if (jjtc009) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                jjtree.closeNodeScope(jjtn009,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
      }
      break;
    case AtomicValue:
      jj_consume_token(AtomicValue);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           SimpleNode jjtn010 = (SimpleNode)SimpleNode.jjtCreate(this, JJTATOMICVALUE);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           boolean jjtc010 = true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           jjtree.openNodeScope(jjtn010);
      try {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           jjtree.closeNodeScope(jjtn010,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           jjtc010 = false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                   jjtn010.processToken(token);
      } finally {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           if (jjtc010) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             jjtree.closeNodeScope(jjtn010,  true);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           }
      }
      break;
    default:
      jj_la1[72] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void ElemOrAttrType() throws ParseException {
 /*@bgen(jjtree) ElemOrAttrType */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTELEMORATTRTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case QName:
        jj_consume_token(QName);
             SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
             }
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OfType:
          SchemaType();
          break;
        default:
          jj_la1[74] = jj_gen;
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case InContext:
            SchemaContext();
            break;
          default:
            jj_la1[73] = jj_gen;
            ;
          }
        }
        break;
      case OfType:
        SchemaType();
        break;
      default:
        jj_la1[75] = 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 SchemaType() throws ParseException {
 /*@bgen(jjtree) SchemaType */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSCHEMATYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(OfType);
            SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTOFTYPE);
            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(QName);
                                                                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTQNAME);
                                                                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 AtomicType() throws ParseException {
 /*@bgen(jjtree) AtomicType */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTATOMICTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(QName);
           SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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);
           }
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void OccurrenceIndicator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Multiply:
    case Star:
    case Plus:
    case QMark:
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Star:
        jj_consume_token(Star);
            SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(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 Multiply:
        jj_consume_token(Multiply);
                                                                   SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTMULTIPLY);
                                                                   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 Plus:
        jj_consume_token(Plus);
                                                                                                                          SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPLUS);
                                                                                                                          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 QMark:
        jj_consume_token(QMark);
                                                                                                                                                                              SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTQMARK);
                                                                                                                                                                              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[76] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      break;
    default:
      jj_la1[77] = jj_gen;
      ;
    }
  }

  public XPathTokenManager token_source;
  ASCII_CharStream jj_input_stream;
  public Token token, jj_nt;
  private int jj_ntk;
  private int jj_gen;
  final private int[] jj_la1 = new int[78];
  final private int[] jj_la1_0 = {0x3ffe1e,0x0,0x0,0x0,0x1200,0x0,0x0,0x1200,0x0,0x0,0x1200,0x1200,0x0,0x10,0x400000,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf000000,0xf000000,0x0,0x0,0x0,0x0,0x0,0x0,0x3ffe1e,0x3ffe1e,0x3ffe1e,0x0,0x0,0x3ffe1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1e,0x157600,0x2a8800,0x0,0x0,0x0,0x0,0x10,0x157600,0x2a8800,0x0,0x0,0xe,0x1e,0x3ffe1e,0x0,0x3ffe1e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x8000000,0x8000000,};
  final private int[] jj_la1_1 = {0x3e000000,0x0,0x10,0x10,0xe000000,0xc0000000,0xc0000000,0x3e000000,0xc0000000,0xc0000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x80,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x28,0x28,0x3e000000,0xe000000,0x3e000000,0xc0000000,0xc0000000,0xe000000,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe000000,0xe000000,0xe000000,0x0,0x0,0xe000000,0x0,0xe000000,0x0,0x0,0x0,0x3e000000,0x0,0x3e000000,0x40000000,0x100000,0x0,0x680700,0x600,0x40000,0x280700,0x0,0x40000,0x40000,0x2000000,0x2000000,};
  final private int[] jj_la1_2 = {0xfe330000,0x0,0x80000,0x80000,0x200000,0x0,0x0,0x200000,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x0,0x8000000,0x6000000,0x6000000,0x0,0x0,0x0,0x0,0xffff,0xffff,0x0,0x30000,0x30000,0x0,0x0,0x30000,0x30000,0x80000,0x80000,0x0,0x0,0xf0300000,0x300000,0x300000,0x0,0x0,0x300000,0x0,0x0,0xc0000000,0xc055,0x3f00,0xa,0xa0,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x200000,0x400000,0x0,0x0,0xfe330000,0x0,0xfe330000,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x60000,0x60000,};
  final private int[] jj_la1_3 = {0x346f80,0x1000,0x0,0x0,0x100780,0x0,0x0,0x300780,0x0,0x0,0x0,0x0,0x1000,0x40000,0x0,0x0,0x0,0x0,0x0,0x1000,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x346780,0x346780,0x346780,0x0,0x0,0x346780,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0x240000,0x0,0x0,0x100780,0x100000,0x0,0x780,0x0,0x102780,0x4000,0x102780,0x0,0x0,0x0,0x346f80,0x1000,0x346f80,0x0,0x100000,0x0,0x100076,0x0,0x100000,0x100076,0x0,0x0,0x100000,0x0,0x0,};
  final private int[] jj_la1_4 = {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,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,};

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

  public void ReInit(java.io.InputStream 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 < 78; i++) jj_la1[i] = -1;
  }

  public XPath(java.io.Reader stream) {
    jj_input_stream = new ASCII_CharStream(stream, 1, 1);
    token_source = new XPathTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 78; 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 < 78; 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 < 78; 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 < 78; 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;

  final public ParseException generateParseException() {
    jj_expentries.removeAllElements();
    boolean[] la1tokens = new boolean[129];
    for (int i = 0; i < 129; i++) {
      la1tokens[i] = false;
    }
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 78; 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;
          }
        }
      }
    }
    for (int i = 0; i < 129; 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() {
  }

                }