options {
        
        
        STATIC = false;
        MULTI=false;
        VISITOR=true ;     // invokes the JJTree Visitor support
        NODE_SCOPE_HOOK=false;
        NODE_USES_PARSER=true;
        FORCE_LA_CHECK=true;
        NODE_PACKAGE="org.w3c.xqparser";
        NODE_PREFIX="";
    
        }

        
        PARSER_BEGIN(XParser)

        package org.w3c.xqparser;

import org.w3c.xqparser.Node;
import org.w3c.xqparser.SimpleNode;

        import java.util.Stack;

        public class XParser {
            

            boolean isStep = false;

            Stack _elementStack = new Stack();

            Stack binaryTokenStack = new Stack();

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


            void processToken(SimpleNode n, Token t)
            {
                
                
                    if(t.kind == XParserConstants.Slash && n.id != XParserTreeConstants.JJTSLASH)
                        return;
                
                n.processToken(t);
            }

            


        }

        PARSER_END(XParser)

    

        TOKEN_MGR_DECLS : {
            public Stack stateStack = new Stack();

            
        void CommonTokenAction(Token t) {}
    

            /**
              * Push the current state onto the state stack.
              */
            private void pushState()
            {
                
                stateStack.addElement(new Integer(curLexState));
            }

            /**
              * Push the given state onto the state stack.
              * @param state Must be a valid state.
              */
            private void pushState(int state)
            {
                
                stateStack.push(new Integer(state));
            }

            /**
              * Pop the state on the state stack, and switch to that state.
              */
            private void popState()
            {
                if (stateStack.size() == 0)
                {
                    // E.g., a would-be query consisting of a single right curly brace.
                    throw new TokenMgrError(
                        "On line " + input_stream.getEndLine() + ","
                        + " the expression contains an 'ending' construct"
                        + " (e.g., a right-brace or end-tag)"
                        + " for which the corresponding 'starting' construct does not appear.",
                        TokenMgrError.LEXICAL_ERROR
                    );
                }

                int nextState = ((Integer) stateStack.pop()).intValue();
                
                SwitchTo(nextState);
            }

            /**
              * Print the current line position.
              */
            public void printLinePos()
            {
                System.err.println("Line: " + input_stream.getEndLine());
            }
        }

        
        SimpleNode START() :
        {}
        {
            XPath()<EOF>
            { if(this.token_source.curLexState == XParserConstants.EXPR_COMMENT)
                throw new ParseException("Unterminated comment.");
            return jjtThis ; }
        }
    void XPath()  :
        {}
        {
            Expr()
        }

    void Expr()  :
        {}
        {
            ExprSingle() ("," ExprSingle())*
        }

    void ExprSingle()  #void :
        {}
        {
            (LOOKAHEAD(2) ForExpr()
                | LOOKAHEAD(2) QuantifiedExpr()
                | LOOKAHEAD(2) IfExpr()
                | OrExpr())
        }

    void ForExpr()  :
        {}
        {
            SimpleForClause() "return" ExprSingle()
        }

    void SimpleForClause()  #void :
        {}
        {
            "for" "$" VarName() "in" ExprSingle() ("," "$" VarName() "in" ExprSingle())*
        }

    void QuantifiedExpr()  :
        {}
        {
            ("some"{jjtThis.processValue("some");}
                | "every"{jjtThis.processValue("every");}) "$" VarName() "in" ExprSingle() ("," "$" VarName() "in" ExprSingle())* "satisfies" ExprSingle()
        }

    void IfExpr()  :
        {}
        {
            "if" "(" Expr() ")" "then" ExprSingle() "else" ExprSingle()
        }

    void OperatorExpr()  #void  : 
        {}
        {
            OrExpr()
        }

        void OrExpr() #OrExpr(> 1) : 
            {}
            {
                AndExpr() ("or"{
                        binaryTokenStack.push(token);
                    } AndExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #OrExpr(2))*
            }

        void AndExpr() #AndExpr(> 1) : 
            {}
            {
                ComparisonExpr() ("and"{
                        binaryTokenStack.push(token);
                    } ComparisonExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #AndExpr(2))*
            }

        void ComparisonExpr() #ComparisonExpr(> 1) : 
            {}
            {
                RangeExpr() ((ValueComp()
                | GeneralComp()
                | NodeComp()) RangeExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #ComparisonExpr(2))?
            }

        void RangeExpr() #RangeExpr(> 1) : 
            {}
            {
                AdditiveExpr() ("to"{
                        binaryTokenStack.push(token);
                    } AdditiveExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #RangeExpr(2))?
            }

        void AdditiveExpr() #AdditiveExpr(> 1) : 
            {}
            {
                MultiplicativeExpr() ((<Plus>
                
                {binaryTokenStack.push(token);}
            
                | <Minus>
                
                {binaryTokenStack.push(token);}
            ) MultiplicativeExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #AdditiveExpr(2))*
            }

        void MultiplicativeExpr() #MultiplicativeExpr(> 1) : 
            {}
            {
                UnionExpr() (("*"{
                        binaryTokenStack.push(token);
                    }
                | "div"{
                        binaryTokenStack.push(token);
                    }
                | "idiv"{
                        binaryTokenStack.push(token);
                    }
                | "mod"{
                        binaryTokenStack.push(token);
                    }) UnionExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #MultiplicativeExpr(2))*
            }

        void UnionExpr() #UnionExpr(> 1) : 
            {}
            {
                IntersectExceptExpr() (("union"{
                        binaryTokenStack.push(token);
                    }
                | "|"{
                        binaryTokenStack.push(token);
                    }) IntersectExceptExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #UnionExpr(2))*
            }

        void IntersectExceptExpr() #IntersectExceptExpr(> 1) : 
            {}
            {
                InstanceofExpr() (("intersect"{
                        binaryTokenStack.push(token);
                    }
                | "except"{
                        binaryTokenStack.push(token);
                    }) InstanceofExpr()
                {
                    try
                    {
                        processToken(jjtThis, (Token)binaryTokenStack.pop());
                    }
                    catch(java.util.EmptyStackException e)
                    {
                        token_source.printLinePos();
                        e.printStackTrace();
                        throw e;
                    }
                }
             #IntersectExceptExpr(2))*
            }

        void InstanceofExpr() #InstanceofExpr(> 1) : 
            {}
            {
                TreatExpr() ( (
    "instance" "of" SequenceType()))?
            }

        void TreatExpr() #TreatExpr(> 1) : 
            {}
            {
                CastableExpr() ( (
    "treat" "as" SequenceType()))?
            }

        void CastableExpr() #CastableExpr(> 1) : 
            {}
            {
                CastExpr() ( (
    "castable" "as" SingleType()))?
            }

        void CastExpr() #CastExpr(> 1) : 
            {}
            {
                UnaryExpr() ( (
    "cast" "as" SingleType()))?
            }

        void UnaryExpr() #UnaryExpr(keepUnary) : 
            {boolean keepUnary=false;}
            {
                ((<Minus>{keepUnary=true;processToken(jjtThis, token);} #Minus(true)
                | <Plus>{keepUnary=true;processToken(jjtThis, token);} #Plus(true)))* ValueExpr()
            }

        void ValueExpr() #void : 
            {}
            {
                PathExpr()
            }

        void GeneralComp()  #void :
        {}
        {
            ("="{
                        binaryTokenStack.push(token);
                    }
                | "!="{
                        binaryTokenStack.push(token);
                    }
                | <LeftAngleBracket>
                        {/* Careful! */ token_source.SwitchTo(DEFAULT); token_source.stateStack.pop(); }
                    
                
                {binaryTokenStack.push(token);}
            
                | "<="{
                        binaryTokenStack.push(token);
                    }
                | ">"{
                        binaryTokenStack.push(token);
                    }
                | ">="{
                        binaryTokenStack.push(token);
                    })
        }

    void ValueComp()  #void :
        {}
        {
            ("eq"{
                        binaryTokenStack.push(token);
                    }
                | "ne"{
                        binaryTokenStack.push(token);
                    }
                | "lt"{
                        binaryTokenStack.push(token);
                    }
                | "le"{
                        binaryTokenStack.push(token);
                    }
                | "gt"{
                        binaryTokenStack.push(token);
                    }
                | "ge"{
                        binaryTokenStack.push(token);
                    })
        }

    void NodeComp()  #void :
        {}
        {
            ("is"{
                        binaryTokenStack.push(token);
                    }
                | "<<"{
                        binaryTokenStack.push(token);
                    }
                | ">>"{
                        binaryTokenStack.push(token);
                    })
        }

    void PathExpr()  #PathExpr(>1) :
        {}
        {
            ( (
    <Slash>{processToken(jjtThis, token);} #Slash(true) [LOOKAHEAD(1) RelativePathExpr()])
                |  (
    <SlashSlash>{processToken(jjtThis, token);} #SlashSlash(true) RelativePathExpr())
                | RelativePathExpr())
        }

    void RelativePathExpr()  #void :
        {}
        {
            StepExpr() ((<Slash>{processToken(((SimpleNode)jjtree.peekNode()), token);}
                | <SlashSlash>{processToken(jjtThis, token);} #SlashSlash(true)) StepExpr())*
        }

    void StepExpr()  #StepExpr(>1 || isStep) :
        {boolean savedIsStep = isStep; isStep=false;}
        {
            (LOOKAHEAD(3) FilterExpr(){isStep = savedIsStep;}
                | {isStep=true;}AxisStep(){isStep = savedIsStep;})
        }

    void AxisStep()  #void :
        {}
        {
            (LOOKAHEAD(2) ReverseStep()
                | ForwardStep()) PredicateList()
        }

    void ForwardStep()  #void :
        {}
        {
            (LOOKAHEAD(2)  (
    ForwardAxis() NodeTest())
                | AbbrevForwardStep())
        }

    void ForwardAxis()  :
        {}
        {
            ( (
    "child"{jjtThis.processValue("child");} "::")
                |  (
    "descendant"{jjtThis.processValue("descendant");} "::")
                |  (
    "attribute"{jjtThis.processValue("attribute");} "::")
                |  (
    "self"{jjtThis.processValue("self");} "::")
                |  (
    "descendant-or-self"{jjtThis.processValue("descendant-or-self");} "::")
                |  (
    "following-sibling"{jjtThis.processValue("following-sibling");} "::")
                |  (
    "following"{jjtThis.processValue("following");} "::")
                |  (
    "namespace"{jjtThis.processValue("namespace");} "::"))
        }

    void AbbrevForwardStep()  :
        {}
        {
            ["@"{jjtThis.processValue("@");}] NodeTest()
        }

    void ReverseStep()  #void :
        {}
        {
            ( (
    ReverseAxis() NodeTest())
                | AbbrevReverseStep())
        }

    void ReverseAxis()  :
        {}
        {
            ( (
    "parent"{jjtThis.processValue("parent");} "::")
                |  (
    "ancestor"{jjtThis.processValue("ancestor");} "::")
                |  (
    "preceding-sibling"{jjtThis.processValue("preceding-sibling");} "::")
                |  (
    "preceding"{jjtThis.processValue("preceding");} "::")
                |  (
    "ancestor-or-self"{jjtThis.processValue("ancestor-or-self");} "::"))
        }

    void AbbrevReverseStep()  :
        {}
        {
            ".."
        }

    void NodeTest()  :
        {}
        {
            (LOOKAHEAD(2) KindTest()
                | NameTest())
        }

    void NameTest()  :
        {}
        {
            (QName()
                | Wildcard())
        }

    void Wildcard()  :
        {}
        {
            ("*"{jjtThis.processValue("*");}
                | <NCNameColonStar>{processToken(jjtThis, token);} #NCNameColonStar(true)
                | <StarColonNCName>{processToken(jjtThis, token);} #StarColonNCName(true))
        }

    void FilterExpr()  #void :
        {}
        {
            PrimaryExpr() PredicateList()
        }

    void PredicateList()  #PredicateList(> 0) :
        {}
        {
            (Predicate())*
        }

    void Predicate()  #Predicate(> 0) :
        {}
        {
            "[" Expr() "]"
        }

    void PrimaryExpr()  #void :
        {}
        {
            (Literal()
                | VarRef()
                | ParenthesizedExpr()
                | {isStep=true;}ContextItemExpr()
                | LOOKAHEAD(2) FunctionCall())
        }

    void Literal()  #void :
        {}
        {
            (NumericLiteral()
                | <StringLiteral>{processToken(jjtThis, token);} #StringLiteral(true))
        }

    void NumericLiteral()  #void :
        {}
        {
            (<IntegerLiteral>{processToken(jjtThis, token);} #IntegerLiteral(true)
                | <DecimalLiteral>{processToken(jjtThis, token);} #DecimalLiteral(true)
                | <DoubleLiteral>{processToken(jjtThis, token);} #DoubleLiteral(true))
        }

    void VarRef()  #void :
        {}
        {
            "$" VarName()
        }

    void VarName()  :
        {}
        {
            QName()
        }

    void ParenthesizedExpr()  :
        {}
        {
            "(" [Expr()] ")"
        }

    void ContextItemExpr()  :
        {}
        {
            "."{jjtThis.processValue(".");}
        }

    void FunctionCall()  :
        {}
        {
            FunctionQName()  (
    "(" [ExprSingle() ("," ExprSingle())*] ")")
        }

    void SingleType()  :
        {}
        {
            AtomicType() ["?"{jjtThis.processValue("?");}]
        }

    void SequenceType()  :
        {}
        {
            (LOOKAHEAD(2)  (
    "empty-sequence"{jjtThis.processValue("empty-sequence");} "(" ")")
                |  (
    ItemType() [LOOKAHEAD(1) OccurrenceIndicator()]))
        }

    void OccurrenceIndicator()  :
        {}
        {
            ("?"{jjtThis.processValue("?");}
                | "*"{jjtThis.processValue("*");}
                | <Plus>{processToken(((SimpleNode)jjtree.peekNode()), token);})
        }

    void ItemType()  :
        {}
        {
            (LOOKAHEAD(2) KindTest()
                | LOOKAHEAD(2)  (
    "item"{jjtThis.processValue("item");} "(" ")")
                | AtomicType())
        }

    void AtomicType()  :
        {}
        {
            QName()
        }

    void KindTest()  #void :
        {}
        {
            (DocumentTest()
                | ElementTest()
                | AttributeTest()
                | SchemaElementTest()
                | SchemaAttributeTest()
                | PITest()
                | CommentTest()
                | TextTest()
                | AnyKindTest())
        }

    void AnyKindTest()  :
        {}
        {
            "node" "(" ")"
        }

    void DocumentTest()  :
        {}
        {
            "document-node" "(" [(ElementTest()
                | SchemaElementTest())] ")"
        }

    void TextTest()  :
        {}
        {
            "text" "(" ")"
        }

    void CommentTest()  :
        {}
        {
            "comment" "(" ")"
        }

    void PITest()  :
        {}
        {
            "processing-instruction" "(" [(NCName()
                | <StringLiteral>{processToken(jjtThis, token);} #StringLiteral(true))] ")"
        }

    void AttributeTest()  :
        {}
        {
            "attribute" "(" [AttribNameOrWildcard() ["," TypeName()]] ")"
        }

    void AttribNameOrWildcard()  :
        {}
        {
            (AttributeName()
                | "*"{jjtThis.processValue("*");})
        }

    void SchemaAttributeTest()  :
        {}
        {
            "schema-attribute" "(" AttributeDeclaration() ")"
        }

    void AttributeDeclaration()  :
        {}
        {
            AttributeName()
        }

    void ElementTest()  :
        {}
        {
            "element" "(" [ElementNameOrWildcard() ["," TypeName() ["?"{jjtThis.processValue("?");}]]] ")"
        }

    void ElementNameOrWildcard()  :
        {}
        {
            (ElementName()
                | "*"{jjtThis.processValue("*");})
        }

    void SchemaElementTest()  :
        {}
        {
            "schema-element" "(" ElementDeclaration() ")"
        }

    void ElementDeclaration()  :
        {}
        {
            ElementName()
        }

    void AttributeName()  :
        {}
        {
            QName()
        }

    void ElementName()  :
        {}
        {
            QName()
        }

    void TypeName()  :
        {}
        {
            QName()
        }

    void NCName()  :
        {}
        {
            QName()
        }

    void QName()  :
        {}
        {
            (FunctionQName()
                | "attribute"{jjtThis.processValue("attribute");}
                | "comment"{jjtThis.processValue("comment");}
                | "document-node"{jjtThis.processValue("document-node");}
                | "element"{jjtThis.processValue("element");}
                | "empty-sequence"{jjtThis.processValue("empty-sequence");}
                | "if"{jjtThis.processValue("if");}
                | "item"{jjtThis.processValue("item");}
                | "node"{jjtThis.processValue("node");}
                | "processing-instruction"{jjtThis.processValue("processing-instruction");}
                | "schema-attribute"{jjtThis.processValue("schema-attribute");}
                | "schema-element"{jjtThis.processValue("schema-element");}
                | "text"{jjtThis.processValue("text");})
        }

    void FunctionQName()  :
        {}
        {
            (<QNameToken>{processToken(((SimpleNode)jjtree.peekNode()), token);}
                | "ancestor"{jjtThis.processValue("ancestor");}
                | "ancestor-or-self"{jjtThis.processValue("ancestor-or-self");}
                | "and"{jjtThis.processValue("and");}
                | "as"{jjtThis.processValue("as");}
                | "cast"{jjtThis.processValue("cast");}
                | "castable"{jjtThis.processValue("castable");}
                | "child"{jjtThis.processValue("child");}
                | "descendant"{jjtThis.processValue("descendant");}
                | "descendant-or-self"{jjtThis.processValue("descendant-or-self");}
                | "div"{jjtThis.processValue("div");}
                | "else"{jjtThis.processValue("else");}
                | "eq"{jjtThis.processValue("eq");}
                | "every"{jjtThis.processValue("every");}
                | "except"{jjtThis.processValue("except");}
                | "following"{jjtThis.processValue("following");}
                | "following-sibling"{jjtThis.processValue("following-sibling");}
                | "for"{jjtThis.processValue("for");}
                | "ge"{jjtThis.processValue("ge");}
                | "gt"{jjtThis.processValue("gt");}
                | "idiv"{jjtThis.processValue("idiv");}
                | "in"{jjtThis.processValue("in");}
                | "instance"{jjtThis.processValue("instance");}
                | "intersect"{jjtThis.processValue("intersect");}
                | "is"{jjtThis.processValue("is");}
                | "le"{jjtThis.processValue("le");}
                | "lt"{jjtThis.processValue("lt");}
                | "mod"{jjtThis.processValue("mod");}
                | "namespace"{jjtThis.processValue("namespace");}
                | "ne"{jjtThis.processValue("ne");}
                | "of"{jjtThis.processValue("of");}
                | "or"{jjtThis.processValue("or");}
                | "parent"{jjtThis.processValue("parent");}
                | "preceding"{jjtThis.processValue("preceding");}
                | "preceding-sibling"{jjtThis.processValue("preceding-sibling");}
                | "return"{jjtThis.processValue("return");}
                | "satisfies"{jjtThis.processValue("satisfies");}
                | "self"{jjtThis.processValue("self");}
                | "some"{jjtThis.processValue("some");}
                | "then"{jjtThis.processValue("then");}
                | "to"{jjtThis.processValue("to");}
                | "treat"{jjtThis.processValue("treat");}
                | "union"{jjtThis.processValue("union");})
        }

    
<DEFAULT>
TOKEN :
{
 < NumericLiteralError : ( (
    "." <Digits>)
                |  (
    <Digits> ("." (["0" - "9"])*)?)) (["e", "E"] (["+", "-"])? <Digits>)? ["a" - "z", "A" - "Z"] >
}

<DEFAULT>
TOKEN :
{
 < Slash : "/" >
}

<DEFAULT>
TOKEN :
{
 < SlashSlash : "//" >
}

<DEFAULT>
TOKEN :
{
 < External : "external" >
}

<DEFAULT>
TOKEN :
{
 < LeftAngleBracket : "<" > { pushState(); } : DEFAULT
}

<DEFAULT>
TOKEN :
{
 < Plus : "+" >
}

<DEFAULT>
TOKEN :
{
 < Minus : "-" >
}

<DEFAULT>
TOKEN :
{
 < NCNameColonStar : <NCNameTok> ":" "*" >
}

<DEFAULT>
TOKEN :
{
 < StarColonNCName : "*" ":" <NCNameTok> >
}

<DEFAULT>
TOKEN :
{
 < IntegerLiteral : <Digits> >
}

<DEFAULT>
TOKEN :
{
 < DecimalLiteral : ( (
    "." <Digits>)
                |  (
    <Digits> "." (["0" - "9"])*)) >
}

<DEFAULT>
TOKEN :
{
 < DoubleLiteral : ( (
    "." <Digits>)
                |  (
    <Digits> ("." (["0" - "9"])*)?)) ["e", "E"] (["+", "-"])? <Digits> >
}

<DEFAULT>
TOKEN :
{
 < StringLiteral : ( (
    "\"" ((<EscapeQuot>
                | ~["\""]))* "\"")
                |  (
    "'" ((<EscapeApos>
                | ~["'"]))* "'")) >
}

TOKEN :
{
 < #EscapeQuot : "\"\"" >
}

TOKEN :
{
 < #EscapeApos : "''" >
}

<DEFAULT>
TOKEN :
{
 < QNameToken : (<NCNameTok> ":")? <LocalPart> >
}

TOKEN :
{
 < #NCNameTok : <Nmstart> (<Nmchar>)* >
}

TOKEN :
{
 < #Char : ["\t", "\r", "\n", "\u0020" - "\uFFFD"] >
}

TOKEN :
{
 < #Digits : (["0" - "9"])+  >
}

TOKEN :
{
 < #WhitespaceChar : ["\t", "\r", "\n", " "] >
}

TOKEN :
{
 < #LocalPart : <NCNameTok> >
}

TOKEN :
{
 < #Nmstart : (<Letter>
                | "_") >
}

TOKEN :
{
 < #Nmchar : (<Letter>
                | <CombiningChar>
                | <Extender>
                | <Digit>
                | "."
                | "-"
                | "_") >
}

TOKEN :
{
 < #Letter : (<BaseChar>
                | <Ideographic>) >
}

TOKEN :
{
 < #BaseChar : ["\u0041" - "\u005a", "\u0061" - "\u007a", "\u00c0" - "\u00d6", "\u00d8" - "\u00f6", "\u00f8" - "\u00ff", "\u0100" - "\u0131", "\u0134" - "\u013e", "\u0141" - "\u0148", "\u014a" - "\u017e", "\u0180" - "\u01c3", "\u01cd" - "\u01f0", "\u01f4" - "\u01f5", "\u01fa" - "\u0217", "\u0250" - "\u02a8", "\u02bb" - "\u02c1", "\u0386", "\u0388" - "\u038a", "\u038c", "\u038e" - "\u03a1", "\u03a3" - "\u03ce", "\u03d0" - "\u03d6", "\u03da", "\u03dc", "\u03de", "\u03e0", "\u03e2" - "\u03f3", "\u0401" - "\u040c", "\u040e" - "\u044f", "\u0451" - "\u045c", "\u045e" - "\u0481", "\u0490" - "\u04c4", "\u04c7" - "\u04c8", "\u04cb" - "\u04cc", "\u04d0" - "\u04eb", "\u04ee" - "\u04f5", "\u04f8" - "\u04f9", "\u0531" - "\u0556", "\u0559", "\u0561" - "\u0586", "\u05d0" - "\u05ea", "\u05f0" - "\u05f2", "\u0621" - "\u063a", "\u0641" - "\u064a", "\u0671" - "\u06b7", "\u06ba" - "\u06be", "\u06c0" - "\u06ce", "\u06d0" - "\u06d3", "\u06d5", "\u06e5" - "\u06e6", "\u0905" - "\u0939", "\u093d", "\u0958" - "\u0961", "\u0985" - "\u098c", "\u098f" - "\u0990", "\u0993" - "\u09a8", "\u09aa" - "\u09b0", "\u09b2", "\u09b6" - "\u09b9", "\u09dc" - "\u09dd", "\u09df" - "\u09e1", "\u09f0" - "\u09f1", "\u0a05" - "\u0a0a", "\u0a0f" - "\u0a10", "\u0a13" - "\u0a28", "\u0a2a" - "\u0a30", "\u0a32" - "\u0a33", "\u0a35" - "\u0a36", "\u0a38" - "\u0a39", "\u0a59" - "\u0a5c", "\u0a5e", "\u0a72" - "\u0a74", "\u0a85" - "\u0a8b", "\u0a8d", "\u0a8f" - "\u0a91", "\u0a93" - "\u0aa8", "\u0aaa" - "\u0ab0", "\u0ab2" - "\u0ab3", "\u0ab5" - "\u0ab9", "\u0abd", "\u0ae0", "\u0b05" - "\u0b0c", "\u0b0f" - "\u0b10", "\u0b13" - "\u0b28", "\u0b2a" - "\u0b30", "\u0b32" - "\u0b33", "\u0b36" - "\u0b39", "\u0b3d", "\u0b5c" - "\u0b5d", "\u0b5f" - "\u0b61", "\u0b85" - "\u0b8a", "\u0b8e" - "\u0b90", "\u0b92" - "\u0b95", "\u0b99" - "\u0b9a", "\u0b9c", "\u0b9e" - "\u0b9f", "\u0ba3" - "\u0ba4", "\u0ba8" - "\u0baa", "\u0bae" - "\u0bb5", "\u0bb7" - "\u0bb9", "\u0c05" - "\u0c0c", "\u0c0e" - "\u0c10", "\u0c12" - "\u0c28", "\u0c2a" - "\u0c33", "\u0c35" - "\u0c39", "\u0c60" - "\u0c61", "\u0c85" - "\u0c8c", "\u0c8e" - "\u0c90", "\u0c92" - "\u0ca8", "\u0caa" - "\u0cb3", "\u0cb5" - "\u0cb9", "\u0cde", "\u0ce0" - "\u0ce1", "\u0d05" - "\u0d0c", "\u0d0e" - "\u0d10", "\u0d12" - "\u0d28", "\u0d2a" - "\u0d39", "\u0d60" - "\u0d61", "\u0e01" - "\u0e2e", "\u0e30", "\u0e32" - "\u0e33", "\u0e40" - "\u0e45", "\u0e81" - "\u0e82", "\u0e84", "\u0e87" - "\u0e88", "\u0e8a", "\u0e8d", "\u0e94" - "\u0e97", "\u0e99" - "\u0e9f", "\u0ea1" - "\u0ea3", "\u0ea5", "\u0ea7", "\u0eaa" - "\u0eab", "\u0ead" - "\u0eae", "\u0eb0", "\u0eb2" - "\u0eb3", "\u0ebd", "\u0ec0" - "\u0ec4", "\u0f40" - "\u0f47", "\u0f49" - "\u0f69", "\u10a0" - "\u10c5", "\u10d0" - "\u10f6", "\u1100", "\u1102" - "\u1103", "\u1105" - "\u1107", "\u1109", "\u110b" - "\u110c", "\u110e" - "\u1112", "\u113c", "\u113e", "\u1140", "\u114c", "\u114e", "\u1150", "\u1154" - "\u1155", "\u1159", "\u115f" - "\u1161", "\u1163", "\u1165", "\u1167", "\u1169", "\u116d" - "\u116e", "\u1172" - "\u1173", "\u1175", "\u119e", "\u11a8", "\u11ab", "\u11ae" - "\u11af", "\u11b7" - "\u11b8", "\u11ba", "\u11bc" - "\u11c2", "\u11eb", "\u11f0", "\u11f9", "\u1e00" - "\u1e9b", "\u1ea0" - "\u1ef9", "\u1f00" - "\u1f15", "\u1f18" - "\u1f1d", "\u1f20" - "\u1f45", "\u1f48" - "\u1f4d", "\u1f50" - "\u1f57", "\u1f59", "\u1f5b", "\u1f5d", "\u1f5f" - "\u1f7d", "\u1f80" - "\u1fb4", "\u1fb6" - "\u1fbc", "\u1fbe", "\u1fc2" - "\u1fc4", "\u1fc6" - "\u1fcc", "\u1fd0" - "\u1fd3", "\u1fd6" - "\u1fdb", "\u1fe0" - "\u1fec", "\u1ff2" - "\u1ff4", "\u1ff6" - "\u1ffc", "\u2126", "\u212a" - "\u212b", "\u212e", "\u2180" - "\u2182", "\u3041" - "\u3094", "\u30a1" - "\u30fa", "\u3105" - "\u312c", "\uac00" - "\ud7a3"] >
}

TOKEN :
{
 < #Ideographic : ["\u4e00" - "\u9fa5", "\u3007", "\u3021" - "\u3029"] >
}

TOKEN :
{
 < #CombiningChar : ["\u0300" - "\u0345", "\u0360" - "\u0361", "\u0483" - "\u0486", "\u0591" - "\u05a1", "\u05a3" - "\u05b9", "\u05bb" - "\u05bd", "\u05bf", "\u05c1" - "\u05c2", "\u05c4", "\u064b" - "\u0652", "\u0670", "\u06d6" - "\u06dc", "\u06dd" - "\u06df", "\u06e0" - "\u06e4", "\u06e7" - "\u06e8", "\u06ea" - "\u06ed", "\u0901" - "\u0903", "\u093c", "\u093e" - "\u094c", "\u094d", "\u0951" - "\u0954", "\u0962" - "\u0963", "\u0981" - "\u0983", "\u09bc", "\u09be", "\u09bf", "\u09c0" - "\u09c4", "\u09c7" - "\u09c8", "\u09cb" - "\u09cd", "\u09d7", "\u09e2" - "\u09e3", "\u0a02", "\u0a3c", "\u0a3e", "\u0a3f", "\u0a40" - "\u0a42", "\u0a47" - "\u0a48", "\u0a4b" - "\u0a4d", "\u0a70" - "\u0a71", "\u0a81" - "\u0a83", "\u0abc", "\u0abe" - "\u0ac5", "\u0ac7" - "\u0ac9", "\u0acb" - "\u0acd", "\u0b01" - "\u0b03", "\u0b3c", "\u0b3e" - "\u0b43", "\u0b47" - "\u0b48", "\u0b4b" - "\u0b4d", "\u0b56" - "\u0b57", "\u0b82" - "\u0b83", "\u0bbe" - "\u0bc2", "\u0bc6" - "\u0bc8", "\u0bca" - "\u0bcd", "\u0bd7", "\u0c01" - "\u0c03", "\u0c3e" - "\u0c44", "\u0c46" - "\u0c48", "\u0c4a" - "\u0c4d", "\u0c55" - "\u0c56", "\u0c82" - "\u0c83", "\u0cbe" - "\u0cc4", "\u0cc6" - "\u0cc8", "\u0cca" - "\u0ccd", "\u0cd5" - "\u0cd6", "\u0d02" - "\u0d03", "\u0d3e" - "\u0d43", "\u0d46" - "\u0d48", "\u0d4a" - "\u0d4d", "\u0d57", "\u0e31", "\u0e34" - "\u0e3a", "\u0e47" - "\u0e4e", "\u0eb1", "\u0eb4" - "\u0eb9", "\u0ebb" - "\u0ebc", "\u0ec8" - "\u0ecd", "\u0f18" - "\u0f19", "\u0f35", "\u0f37", "\u0f39", "\u0f3e", "\u0f3f", "\u0f71" - "\u0f84", "\u0f86" - "\u0f8b", "\u0f90" - "\u0f95", "\u0f97", "\u0f99" - "\u0fad", "\u0fb1" - "\u0fb7", "\u0fb9", "\u20d0" - "\u20dc", "\u20e1", "\u302a" - "\u302f", "\u3099", "\u309a"] >
}

TOKEN :
{
 < #Digit : ["\u0030" - "\u0039", "\u0660" - "\u0669", "\u06f0" - "\u06f9", "\u0966" - "\u096f", "\u09e6" - "\u09ef", "\u0a66" - "\u0a6f", "\u0ae6" - "\u0aef", "\u0b66" - "\u0b6f", "\u0be7" - "\u0bef", "\u0c66" - "\u0c6f", "\u0ce6" - "\u0cef", "\u0d66" - "\u0d6f", "\u0e50" - "\u0e59", "\u0ed0" - "\u0ed9", "\u0f20" - "\u0f29"] >
}

TOKEN :
{
 < #Extender : ["\u00b7", "\u02d0", "\u02d1", "\u0387", "\u0640", "\u0e46", "\u0ec6", "\u3005", "\u3031" - "\u3035", "\u309d" - "\u309e", "\u30fc" - "\u30fe"] >
}

<DEFAULT, EXPR_COMMENT>
SKIP :
{
 < CommentStart : "(:" > { pushState(); } : EXPR_COMMENT
}

<EXPR_COMMENT>
SKIP :
{
 < CommentEnd : ":)" > { popState(); }
}

<EXPR_COMMENT>
SKIP :
{
 < CommentContent : <Char> >
}

<DEFAULT>
SKIP :
{
 < ImplicitlyAllowedWhitespace : (<WhitespaceChar>)+  >
}