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


import java.util.Stack;

public class XPath/*@bgen(jjtree)*/implements XPathTreeConstants, XPathConstants {/*@bgen(jjtree)*/
  protected JJTXPathState jjtree = new JJTXPathState();
      org.apache.xml.utils.PrefixResolver m_prefixResolver;
      org.apache.xpath.patterns.FunctionPattern m_matchFunc = null; // short lived.

      int m_predLevel = 0;

      public void setPrefixResolver(org.apache.xml.utils.PrefixResolver resolver)
      {
        m_prefixResolver = resolver;
      }

      public org.apache.xml.utils.PrefixResolver getPrefixResolver()
      {
        return m_prefixResolver;
      }

          /**
	   * The "version" property.
	   * @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 of XPath.
	   *
	   * @return The value of the "version" property.
	   */
          public double getVersion()
          {
            return m_version;
          }


      boolean m_isMatchPattern = false;

                  Stack binaryTokenStack = new Stack();
                  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 {
      Expr();
      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 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[0] = 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[1] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        Pattern();
        break;
      default:
        jj_la1[2] = 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[3] = 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);
                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);
                }
            }
            break;
          case SlashSlash:
            jj_consume_token(SlashSlash);
                SimpleNode jjtn004 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASHSLASH);
                boolean jjtc004 = true;
                jjtree.openNodeScope(jjtn004);
            try {
                jjtree.closeNodeScope(jjtn004,  true);
                jjtc004 = false;
               jjtn004.processToken(token);
            } finally {
                if (jjtc004) {
                  jjtree.closeNodeScope(jjtn004,  true);
                }
            }
            break;
          default:
            jj_la1[4] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          RelativePathPattern();
          break;
        default:
          jj_la1[5] = 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[6] = 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);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASH);
                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 SlashSlash:
        jj_consume_token(SlashSlash);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASHSLASH);
                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[7] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      RelativePathPattern();
      break;
    default:
      jj_la1[8] = 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[9] = 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[10] = 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[11] = 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 IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case StringLiteral:
      Literal();
      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;
    default:
      jj_la1[12] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

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

  final public void OrExpr() throws ParseException {
    AndExpr();
    label_2:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Or:
        ;
        break;
      default:
        jj_la1[13] = 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);
                  }
      }
    }
  }

  final public void AndExpr() throws ParseException {
    FLWRExpr();
    label_3:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case And:
        ;
        break;
      default:
        jj_la1[14] = 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);
                  }
      }
    }
  }

  final public void FLWRExpr() throws ParseException {
 /*@bgen(jjtree) FLWRExpr */
  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[15] = jj_gen;
          break label_4;
        }
        ForClause();
        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, true);
    }
    }
  }

  final public void QuantifiedExpr() throws ParseException {
 /*@bgen(jjtree) QuantifiedExpr */
  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[16] = 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[17] = 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[18] = 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, true);
    }
    }
  }

  final public void IfExpr() throws ParseException {
 /*@bgen(jjtree) IfExpr */
  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[19] = jj_gen;
          break label_7;
        }
        jj_consume_token(IfLpar);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIFLPAR);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
        try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
        } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
        }
        Expr();
        jj_consume_token(Rpar);
        jj_consume_token(Then);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTHEN);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
        try {
                jjtree.closeNodeScope(jjtn002,  true);
                jjtc002 = false;
               jjtn002.processToken(token);
        } finally {
                if (jjtc002) {
                  jjtree.closeNodeScope(jjtn002,  true);
                }
        }
        Expr();
        jj_consume_token(Else);
                SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTELSE);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
        try {
                jjtree.closeNodeScope(jjtn003,  true);
                jjtc003 = false;
               jjtn003.processToken(token);
        } finally {
                if (jjtc003) {
                  jjtree.closeNodeScope(jjtn003,  true);
                }
        }
      }
      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, true);
    }
    }
  }

  final public void InstanceofExpr() throws ParseException {
 /*@bgen(jjtree) InstanceofExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTINSTANCEOFEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      ComparisonExpr();
      label_8:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Instanceof:
          ;
          break;
        default:
          jj_la1[20] = jj_gen;
          break label_8;
        }
        jj_consume_token(Instanceof);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTINSTANCEOF);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
        try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
        } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
        }
        SequenceType();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ComparisonExpr() throws ParseException {
    RangeExpr();
    label_9:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Precedes:
      case Follows:
      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[21] = jj_gen;
        break label_9;
      }
      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 Precedes:
      case Follows:
      case LtLt:
      case GtGt:
        OrderComp();
        break;
      default:
        jj_la1[22] = 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);
                  }
      }
    }
  }

  final public void RangeExpr() throws ParseException {
    AdditiveExpr();
    label_10:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case To:
        ;
        break;
      default:
        jj_la1[23] = jj_gen;
        break label_10;
      }
      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);
                  }
      }
    }
  }

  final public void AdditiveExpr() throws ParseException {
    MultiplicativeExpr();
    label_11:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Minus:
      case Plus:
        ;
        break;
      default:
        jj_la1[24] = jj_gen;
        break label_11;
      }
      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[25] = 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);
                  }
      }
    }
  }

  final public void MultiplicativeExpr() throws ParseException {
    UnionExpr();
    label_12:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Div:
      case Idiv:
      case Mod:
      case Multiply:
        ;
        break;
      default:
        jj_la1[26] = jj_gen;
        break label_12;
      }
      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[27] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      UnionExpr();
                  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);
                  }
      }
    }
  }

  final public void UnionExpr() throws ParseException {
    IntersectExceptExpr();
    label_13:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Union:
      case Vbar:
        ;
        break;
      default:
        jj_la1[28] = jj_gen;
        break label_13;
      }
      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[29] = 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);
                  }
      }
    }
  }

  final public void IntersectExceptExpr() throws ParseException {
    UnaryExpr();
    label_14:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Intersect:
      case Except:
        ;
        break;
      default:
        jj_la1[30] = jj_gen;
        break label_14;
      }
      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[31] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      UnaryExpr();
                  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);
                  }
      }
    }
  }

  final public void UnaryExpr() throws ParseException {
 /*@bgen(jjtree) UnaryExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTUNARYEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_15:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Minus:
        case Plus:
          ;
          break;
        default:
          jj_la1[32] = jj_gen;
          break label_15;
        }
        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;
               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;
               jjtn002.processToken(token);
          } finally {
                if (jjtc002) {
                  jjtree.closeNodeScope(jjtn002,  true);
                }
          }
          break;
        default:
          jj_la1[33] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      ValueExpr();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void ValueExpr() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case Validate:
      ValidateExpr();
      break;
    case CastAs:
    case TreatAs:
      CastExpr();
      break;
    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 IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case StringLiteral:
    case Dot:
    case DotDot:
    case VariableIndicator:
    case QName:
    case QNameLpar:
      PathExpr();
      break;
    default:
      jj_la1[34] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void PathExpr() throws ParseException {
 /*@bgen(jjtree) PathExpr */
  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 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 IntegerLiteral:
        case DecimalLiteral:
        case DoubleLiteral:
        case NodeLpar:
        case CommentLpar:
        case TextLpar:
        case ProcessingInstructionLpar:
        case StringLiteral:
        case Dot:
        case DotDot:
        case VariableIndicator:
        case QName:
        case QNameLpar:
          RelativePathExpr();
          break;
        default:
          jj_la1[35] = 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 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 IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case StringLiteral:
      case Dot:
      case DotDot:
      case VariableIndicator:
      case QName:
      case QNameLpar:
        RelativePathExpr();
        break;
      default:
        jj_la1[36] = 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 RelativePathExpr() throws ParseException {
    StepExpr();
    label_16:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Slash:
      case SlashSlash:
        ;
        break;
      default:
        jj_la1[37] = jj_gen;
        break label_16;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Slash:
        jj_consume_token(Slash);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASH);
                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 SlashSlash:
        jj_consume_token(SlashSlash);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSLASHSLASH);
                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[38] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      StepExpr();
    }
  }

  final public void StepExpr() throws ParseException {
 /*@bgen(jjtree) StepExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTSTEPEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    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();
        break;
      case AxisParent:
      case AxisAncestor:
      case AxisPrecedingSibling:
      case AxisPreceding:
      case AxisAncestorOrSelf:
      case DotDot:
        ReverseStep();
        break;
      case Lpar:
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case StringLiteral:
      case VariableIndicator:
      case QNameLpar:
        PrimaryExpr();
        break;
      default:
        jj_la1[39] = 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, true);
    }
    }
  }

  final public void ForClause() throws ParseException {
 /*@bgen(jjtree) ForClause */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTFORCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      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_17:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Comma:
          ;
          break;
        default:
          jj_la1[40] = jj_gen;
          break label_17;
        }
        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();
      }
    } 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 ValidateExpr() throws ParseException {
 /*@bgen(jjtree) ValidateExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTVALIDATEEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(Validate);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTVALIDATE);
                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 In:
        SchemaContext();
        break;
      default:
        jj_la1[41] = jj_gen;
        ;
      }
      jj_consume_token(Lbrace);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLBRACE);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
      try {
                jjtree.closeNodeScope(jjtn002,  true);
                jjtc002 = false;
               jjtn002.processToken(token);
      } finally {
                if (jjtc002) {
                  jjtree.closeNodeScope(jjtn002,  true);
                }
      }
      Expr();
      jj_consume_token(Rbrace);
                SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRBRACE);
                boolean jjtc003 = true;
                jjtree.openNodeScope(jjtn003);
      try {
                jjtree.closeNodeScope(jjtn003,  true);
                jjtc003 = false;
               jjtn003.processToken(token);
      } finally {
                if (jjtc003) {
                  jjtree.closeNodeScope(jjtn003,  true);
                }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void CastExpr() throws ParseException {
 /*@bgen(jjtree) CastExpr */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCASTEXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CastAs:
        jj_consume_token(CastAs);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTCASTAS);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
        try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
        } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
        }
        break;
      case TreatAs:
        jj_consume_token(TreatAs);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTREATAS);
                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[42] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      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[43] = 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[44] = 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[45] = 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;
    case Precedes:
      jj_consume_token(Precedes);
          binaryTokenStack.push(token);
      break;
    case Follows:
      jj_consume_token(Follows);
          binaryTokenStack.push(token);
      break;
    default:
      jj_la1[46] = 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[47] = 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[48] = 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[49] = 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[50] = 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[51] = 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[52] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void KindTest() throws ParseException {
 /*@bgen(jjtree) KindTest */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTKINDTEST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      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[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 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[54] = 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[55] = 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[56] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
  }

  final public void AbbreviatedForwardStep() throws ParseException {
 /*@bgen(jjtree) AbbreviatedForwardStep */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTABBREVIATEDFORWARDSTEP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      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[57] = 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 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 */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTPREDICATES);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_18:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Lbrack:
          ;
          break;
        default:
          jj_la1[58] = jj_gen;
          break label_18;
        }
        jj_consume_token(Lbrack);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTLBRACK);
                boolean jjtc001 = true;
                jjtree.openNodeScope(jjtn001);
        try {
                jjtree.closeNodeScope(jjtn001,  true);
                jjtc001 = false;
               jjtn001.processToken(token);
        } finally {
                if (jjtc001) {
                  jjtree.closeNodeScope(jjtn001,  true);
                }
        }
        Expr();
        jj_consume_token(Rbrack);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTRBRACK);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
        try {
                jjtree.closeNodeScope(jjtn002,  true);
                jjtc002 = false;
               jjtn002.processToken(token);
        } finally {
                if (jjtc002) {
                  jjtree.closeNodeScope(jjtn002,  true);
                }
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void 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[59] = 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[60] = 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 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 Validate:
    case IntegerLiteral:
    case DecimalLiteral:
    case DoubleLiteral:
    case NodeLpar:
    case CommentLpar:
    case TextLpar:
    case ProcessingInstructionLpar:
    case IfLpar:
    case StringLiteral:
    case Dot:
    case DotDot:
    case VariableIndicator:
    case QName:
    case QNameLpar:
      ExprSequence();
      break;
    default:
      jj_la1[61] = 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 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 Validate:
      case IntegerLiteral:
      case DecimalLiteral:
      case DoubleLiteral:
      case NodeLpar:
      case CommentLpar:
      case TextLpar:
      case ProcessingInstructionLpar:
      case IfLpar:
      case StringLiteral:
      case Dot:
      case DotDot:
      case VariableIndicator:
      case QName:
      case QNameLpar:
        Expr();
        label_19:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case Comma:
            ;
            break;
          default:
            jj_la1[62] = jj_gen;
            break label_19;
          }
          jj_consume_token(Comma);
          Expr();
        }
        break;
      default:
        jj_la1[63] = 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(In);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTIN);
                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_20:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Slash:
          ;
          break;
        default:
          jj_la1[64] = jj_gen;
          break label_20;
        }
        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 Type:
        jj_consume_token(Type);
                SimpleNode jjtn002 = (SimpleNode)SimpleNode.jjtCreate(this, JJTTYPE);
                boolean jjtc002 = true;
                jjtree.openNodeScope(jjtn002);
        try {
                jjtree.closeNodeScope(jjtn002,  true);
                jjtc002 = false;
               jjtn002.processToken(token);
        } finally {
                if (jjtc002) {
                  jjtree.closeNodeScope(jjtn002,  true);
                }
        }
        jj_consume_token(QName);
                SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTQNAME);
                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[65] = 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 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[66] = 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 {
 /*@bgen(jjtree) ItemType */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTITEMTYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      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[67] = 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[68] = 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[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 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[71] = jj_gen;
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case In:
            SchemaContext();
            break;
          default:
            jj_la1[70] = jj_gen;
            ;
          }
        }
        break;
      case OfType:
        SchemaType();
        break;
      default:
        jj_la1[72] = 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 {
 /*@bgen(jjtree) OccurrenceIndicator */
  SimpleNode jjtn000 = (SimpleNode)SimpleNode.jjtCreate(this, JJTOCCURRENCEINDICATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case Multiply:
      case Plus:
      case QMark:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case Multiply:
          jj_consume_token(Multiply);
                SimpleNode jjtn001 = (SimpleNode)SimpleNode.jjtCreate(this, JJTMULTIPLY);
                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 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;
               jjtn002.processToken(token);
          } finally {
                if (jjtc002) {
                  jjtree.closeNodeScope(jjtn002,  true);
                }
          }
          break;
        case QMark:
          jj_consume_token(QMark);
                SimpleNode jjtn003 = (SimpleNode)SimpleNode.jjtCreate(this, JJTQMARK);
                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[73] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[74] = jj_gen;
        ;
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  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[75];
  final private int[] jj_la1_0 = {0x0,0x80000000,0x80000000,0x120,0x0,0x0,0x120,0x0,0x0,0x120,0x120,0x0,0x0,0x40000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0xf00000,0xf00000,0x80000000,0x80000000,0x40000000,0x40000000,0x0,0x0,0x3ffe0,0x3ffe0,0x3ffe0,0x0,0x0,0x3ffe0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x15760,0x2a880,0x0,0x0,0x0,0x0,0x0,0x15760,0x2a880,0x0,0x0,0x0,0x0,0x3ffe0,0x0,0x3ffe0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x800000,0x800000,};
  final private int[] jj_la1_1 = {0x0,0x0,0x0,0x700000,0x6000000,0x6000000,0x1f00000,0x6000000,0x6000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0xf8000006,0xf8000006,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x1f00000,0x700000,0x1f00000,0x6000000,0x6000000,0x700000,0x0,0x0,0x0,0xa8000000,0x0,0x50000000,0x6,0x0,0x0,0x0,0x700000,0x700000,0x700000,0x0,0x0,0x700000,0x0,0x700000,0x0,0x0,0x0,0x1f00000,0x0,0x1f00000,0x2000000,0x8000,0x34070,0x60,0x2000,0x14070,0x0,0x2000,0x2000,0x0,0x0,};
  final private int[] jj_la1_2 = {0x0,0x4000,0x4000,0x10000,0x0,0x0,0x10000,0x0,0x0,0x10000,0x10000,0x0,0x38000000,0x0,0x0,0x400000,0x300000,0x300000,0x0,0x0,0x0,0x7ff,0x7ff,0x0,0x1800,0x1800,0x0,0x0,0x4000,0x4000,0x0,0x0,0x1800,0x1800,0x3b818000,0x38018000,0x38018000,0x0,0x0,0x38018000,0x0,0x0,0x1800000,0x602,0x1f8,0x0,0x5,0x38008000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x10000,0x20000,0x38000000,0x38000000,0x3bf19800,0x0,0x3bf19800,0x0,0x0,0xc0000000,0x0,0x0,0xc0000000,0x0,0x0,0x0,0x3000,0x3000,};
  final private int[] jj_la1_3 = {0x200,0x0,0x0,0x800f0,0x0,0x0,0x4800f0,0x0,0x0,0x0,0x0,0x200,0x20400,0x0,0x0,0x0,0x0,0x0,0x200,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4a34f0,0x4a34f0,0x4a34f0,0x0,0x0,0x4a34f0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x420400,0x0,0x0,0x800f0,0x80000,0x0,0xf0,0x400,0x810f0,0x2000,0x810f0,0x0,0x0,0x400,0x4a35f0,0x200,0x4a35f0,0x0,0x80000,0x8000e,0x0,0x80000,0x8000e,0x0,0x0,0x80000,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,};

  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 < 75; 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 < 75; 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 < 75; 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 < 75; 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 < 75; 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 < 75; 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 < 75; 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() {
  }

                }