{"version":3,"sources":["smack-compiler-min-orig.js"],"names":["e","t","n","r","s","o","u","a","require","i","Error","f","exports","call","length","1","module","TokenStream","this","BufferedTokenStream","tokenSource","tokens","index","fetchedEOF","Token","Lexer","Interval","prototype","Object","create","constructor","mark","release","marker","reset","seek","lazyInit","adjustSeekIndex","get","consume","skipEofCheck","LA","EOF","sync","fetched","fetch","nextToken","tokenIndex","push","type","getTokens","start","stop","types","undefined","subset","contains","LT","LB","k","setup","setTokenSource","nextTokenOnChannel","channel","token","previousTokenOnChannel","getHiddenTokensToRight","nextOnChannel","DEFAULT_TOKEN_CHANNEL","from_","to","filterForChannel","getHiddenTokensToLeft","prevOnChannel","left","right","hidden","getSourceName","getText","interval","fill","text","./IntervalSet","./Lexer","./Token","2","TokenFactory","CommonTokenFactory","copyText","CommonToken","DEFAULT","source","line","column","createThin","3","CommonTokenStream","lexer","DEFAULT_CHANNEL","getNumberOfOnChannelTokens","./BufferedTokenStream","4","FileStream","fileName","data","fs","readFileSync","InputStream","isNodeJs","window","importScripts","./InputStream","5","_loadString","stream","_index","strdata","charCodeAt","_size","name","defineProperty","offset","pos","Math","min","slice","toString","6","IntervalSet","intervals","readOnly","item","first","v","INVALID_TYPE","addOne","addInterval","addRange","l","h","splice","max","reduce","addSet","other","intervalslength","pop","complement","result","removeRange","len","map","removeOne","x","literalNames","symbolicNames","elemsAreChar","toTokenString","toCharString","toIndexString","names","String","fromCharCode","join","j","elementName","EPSILON","7","LL1Analyzer","atn","Set","BitSet","ATNConfig","RuleStopState","RuleTransition","NotSetTransition","WildcardTransition","AbstractPredicateTransition","pc","predictionContextFromRuleContext","PredictionContext","SingletonPredictionContext","HIT_PRED","getDecisionLookahead","count","transitions","look","alt","lookBusy","seeThruPreds","_LOOK","transition","target","EMPTY","LOOK","stopState","ctx","lookContext","calledRuleStack","addEOF","c","state","context","add","isEmpty","returnState","states","getReturnState","removed","ruleIndex","remove","getParent","newContext","followState","stateNumber","isEpsilon","MIN_USER_TOKEN_TYPE","maxTokenType","set","label","./PredictionContext","./Utils","./atn/ATNConfig","./atn/ATNState","./atn/Transition","8","input","Recognizer","_input","_factory","_tokenFactorySourcePair","_interp","_token","_tokenStartCharIndex","_tokenStartLine","_tokenStartColumn","_hitEOF","_channel","_type","_modeStack","_mode","DEFAULT_MODE","_text","LexerNoViableAltException","MORE","SKIP","HIDDEN","HIDDEN_CHANNEL","MIN_CHAR_VALUE","MAX_CHAR_VALUE","tokenStartMarker","emitEOF","continueOuter","ttype","match","notifyListeners","recover","emit","skip","more","mode","m","pushMode","debug","console","log","popMode","sourceName","emitToken","getCharIndex","cpos","lpos","eof","getAllTokens","msg","getErrorDisplay","listener","getErrorListenerDispatch","syntaxError","d","getErrorDisplayForChar","getCharErrorDisplay","re","./CommonTokenFactory","./Recognizer","./error/Errors","9","TraceListener","parser","ParseTreeListener","Parser","_errHandler","DefaultErrorStrategy","_precedenceStack","_ctx","buildParseTrees","_tracer","_parseListeners","_syntaxErrors","setInputStream","ATNDeserializer","ATNDeserializationOptions","enterEveryRule","ruleNames","visitTerminal","node","symbol","exitEveryRule","contructor","bypassAltsAtnCache","setTrace","getCurrentToken","reportMatch","recoverInline","addErrorNode","matchWildcard","_buildParseTrees","getParseListeners","addParseListener","removeParseListener","idx","indexOf","removeParseListeners","triggerEnterRuleEvent","enterRule","triggerExitRuleEvent","reverse","exitRule","getTokenFactory","setTokenFactory","factory","getATNWithBypassAlts","serializedAtn","getSerializedATN","deserializationOptions","generateRuleBypassTransitions","deserialize","compileParseTreePattern","pattern","patternRuleIndex","getTokenStream","ParseTreePatternMatcher","compile","getInputStream","setTokenStream","notifyErrorListeners","offendingToken","err","hasListener","inErrorRecoveryMode","addTokenNode","invokingState","addContextToParseTree","parentCtx","addChild","localctx","enterOuterAlt","altNum","setAltNumber","removeLastChild","getPrecedence","enterRecursionRule","precedence","pushNewRecursionContext","previous","unrollRecursionContexts","retCtx","getInvokingContext","precpred","inContext","isExpectedToken","following","nextTokens","rt","getExpectedTokens","getExpectedTokensWithinCurrentRule","getRuleIndex","ruleName","getRuleIndexMap","getRuleInvocationStack","p","stack","getDFAStrings","decisionToDFA","dumpDFA","seenOne","dfa","printer","println","decision","print","trace","./atn/ATNDeserializationOptions","./atn/ATNDeserializer","./error/ErrorStrategy","./tree/Tree","10","ParserRuleContext","parent","invokingStateNumber","RuleContext","children","exception","InterpreterRuleContext","Tree","INVALID_INTERVAL","TerminalNode","TerminalNodeImpl","ErrorNodeImpl","copyFrom","child","badToken","getChild","getToken","getTypedRuleContext","ctxType","getTypedRuleContexts","contexts","getChildCount","getSourceInterval","./RuleContext","11","cachedHashString","calculateHashString","calculateEmptyHashString","PredictionContextCache","cache","hashString","EmptyPredictionContext","EMPTY_RETURN_STATE","ArrayPredictionContext","parents","returnStates","hash","outerContext","merge","b","rootIsWildcard","mergeCache","mergeSingletons","mergeArrays","rootMerge","mergeRoot","spc","singleParent","payloads","apc","a_","mergedReturnStates","mergedParents","a_parent","b_parent","payload","bothDollars","ax_ax","mergedParent","M","combineCommonParents","uniqueParents","q","getCachedPredictionContext","contextCache","visited","existing","changed","updated","globalNodeCount","id","hasEmptyPath","equals","up","12","_listeners","ConsoleErrorListener","INSTANCE","_stateNumber","ProxyErrorListener","tokenTypeMapCache","ruleIndexMapCache","checkVersion","toolVersion","runtimeVersion","addErrorListener","removeErrorListeners","getTokenTypeMap","tokenNames","getTokenNames","getRuleNames","getTokenType","tokenName","getErrorHeader","getOffendingToken","getTokenErrorDisplay","replace","sempred","actionIndex","./error/ErrorListener","13","RuleNode","INVALID_ALT_NUMBER","depth","getRuleContext","getPayload","getAltNumber","altNumber","accept","visitor","visitChildren","Trees","toStringTree","recog","ri","./atn/ATN","./tree/Trees","14","EMPTY_SOURCE","getTokenSource","clone","size","txt","15","arrayToString","standardEqualsFunction","standardHashFunction","hashFunction","equalsFunction","AltDict","DoubleDict","escapeWhitespace","escapeSpaces","hashCode","character","values","value","key","concat","or","bits","keys","minValue","apply","put","isArray","entity","titleCase","str","charAt","toUpperCase","substr","16","ATN","grammarType","decisionToState","ruleToStartState","ruleToStopState","modeNameToStartState","ruleToTokenType","lexerActions","modeToStartState","nextTokensInContext","anal","nextTokensNoContext","nextTokenWithinRule","addState","removeState","defineDecisionState","getDecisionState","expected","./../IntervalSet","./../LL1Analyzer","./../Token","17","checkParams","params","isCfg","semanticContext","reachesIntoOuterContext","props","precedenceFilterSuppressed","config","checkContext","SemanticContext","NONE","LexerATNConfig","lexerActionExecutor","passedThroughNonGreedyDecision","checkNonGreedyDecision","DecisionState","shortHashString","nonGreedy","./ATNState","./SemanticContext","18","hashATNConfig","equalATNConfigs","ATNConfigSet","fullCtx","configLookup","configs","uniqueAlt","conflictingAlts","hasSemanticContext","dipsIntoOuterContext","OrderedATNConfigSet","Utils","merged","getStates","getPredicates","preds","optimizeConfigs","interpreter","getCachedContext","addAll","coll","hashConfigs","containsFast","clear","setReadonly","./../PredictionContext","./../Utils","./ATN","19","verifyATN","defaultOptions","20","initArray","tmp","options","stateFactories","actionFactories","createByteToHex","bth","ATNType","ATNStates","ATNState","BasicState","BlockStartState","BlockEndState","LoopEndState","RuleStartState","TokensStartState","PlusLoopbackState","StarLoopbackState","StarLoopEntryState","PlusBlockStartState","StarBlockStartState","BasicBlockStartState","Transitions","Transition","AtomTransition","SetTransition","RangeTransition","ActionTransition","EpsilonTransition","PredicateTransition","PrecedencePredicateTransition","LexerActions","LexerActionType","LexerSkipAction","LexerChannelAction","LexerCustomAction","LexerMoreAction","LexerTypeAction","LexerPushModeAction","LexerPopModeAction","LexerModeAction","BASE_SERIALIZED_UUID","SUPPORTED_UUIDS","SERIALIZED_VERSION","SERIALIZED_UUID","isFeatureSupported","feature","actualUuid","idx1","idx2","checkUUID","readATN","readStates","readRules","readModes","sets","readSets","readEdges","readDecisions","readLexerActions","markPrecedenceDecisions","PARSER","adjust","temp","split","version","readInt","uuid","readUUID","pair","loopBackStateNumbers","endStateNumbers","nstates","stype","stateFactory","LOOP_END","loopBackStateNumber","endStateNumber","loopBackState","endState","numNonGreedyStates","numPrecedenceStates","isPrecedenceRule","nrules","LEXER","startState","tokenType","nmodes","iset","containsEof","i1","i2","trans","nedges","src","trg","arg1","arg2","arg3","edgeFactory","srcState","addTransition","outermostPrecedenceReturn","ndecisions","decState","actionType","data1","data2","lexerAction","lexerActionFactory","generateRuleBypassTransition","bypassStart","bypassStop","excludeTransition","stateIsEndStateFor","matchState","maybeLoopEndState","epsilonOnlyTransitions","precedenceRuleDecision","checkCondition","condition","message","readInt32","low","high","readLong","byteToHex","bb","int","RANGE","RULE","PREDICATE","PRECEDENCE","ATOM","ACTION","SET","NOT_SET","WILDCARD","sf","BASIC","RULE_START","BLOCK_START","PLUS_BLOCK_START","STAR_BLOCK_START","TOKEN_START","RULE_STOP","BLOCK_END","STAR_LOOP_BACK","STAR_LOOP_ENTRY","PLUS_LOOP_BACK","af","CHANNEL","CUSTOM","MODE","POP_MODE","PUSH_MODE","TYPE","./ATNDeserializationOptions","./ATNType","./LexerAction","./Transition","21","ATNSimulator","sharedContextCache","DFAState","ERROR","./../dfa/DFAState","./ATNConfigSet","22","INVALID_STATE_NUMBER","stateType","serializationNames","isNonGreedyExitState","23","24","resetSimState","sim","dfaState","SimState","LexerATNSimulator","startIndex","prevAccept","LexerActionExecutor","dfa_debug","MIN_DFA_EDGE","MAX_DFA_EDGE","match_calls","copyState","simulator","s0","matchATN","execATN","old_mode","s0_closure","computeStartState","suppressEdge","next","addDFAState","predict","toLexerString","ds0","isAcceptState","captureSimState","getExistingTargetState","computeTargetState","failOrAccept","edges","reach","getReachableConfigSet","items","addDFAEdge","prediction","closure","skipAlt","cfg","currentAltReachedAcceptState","getTokenName","getReachableTarget","fixOffsetBeforeMatch","treatEofAsEpsilon","charPos","execute","matches","initialContext","speculative","getEpsilonTarget","serializationType","predIndex","evaluatePredicate","append","savedcolumn","savedLine","settings","tk","cfgs","proposed","firstConfigWithRuleStopState","newState","getDFA","curChar","tt","./../Lexer","./../error/Errors","./ATNConfig","./ATNSimulator","./LexerActionExecutor","25","LexerAction","action","isPositionDependent","LexerIndexedCustomAction","26","_hashString","updatedLexerActions","requiresSeek","stopIndex","numActions","27","ParserATNSimulator","predictionMode","PredictionMode","LL","_startIndex","_outerContext","_dfa","PredPrediction","NoViableAltException","debug_list_atn_decisions","retry_debug","adaptivePredict","getLookaheadName","precedenceDfa","getPrecedenceStartState","atnStartState","setPrecedenceDfa","applyPrecedenceFilter","setPrecedenceStartState","previousD","D","noViableAlt","getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule","requiresFullContext","SLL","predicates","conflictIndex","evalSemanticContext","reportAttemptingFullContext","execATNWithFullContext","alts","reportAmbiguity","computeReachSet","predictedAlt","getUniqueAlt","altSubSets","getConflictingAltSubsets","allSubsetsConflict","getConflictingAlts","hasSLLConflictTerminatingPrediction","predicateDFAState","decisionState","nalts","altsToCollectPredsFrom","getConflictingAltsOrUniqueAlt","altToPred","getPredsForAmbigAlts","getPredicatePredictions","foundExactAmbig","resolvesToJustOneViableAlt","LL_EXACT_AMBIG_DETECTION","allSubsetsEqual","getSingleViableAlt","reportContextSensitivity","intermediate","skippedStopStates","closureBusy","removeAllConfigsNotInRuleStopState","hasConfigInRuleStopState","lookToEndOfRule","allConfigsInRuleStopStates","endOfRuleState","statesFromAlt1","configSet","updatedContext","evalPrecedence","ambigAlts","orContext","nPredAlts","pred","pairs","containsPredicate","splitAccordingToSemanticValidity","semValidConfigs","semInvalidConfigs","getAltThatFinishedDecisionEntryRule","succeeded","failed","predicateEvaluationResult","evaluate","predPredictions","complete","predictions","collectPredicates","initialDepth","closureCheckingStopState","parms","getRuleName","closure_","continueCollecting","newDepth","ruleTransition","precedenceTransition","predTransition","actionTransition","pt","currentPosition","predSucceeds","getPredicate","newSemCtx","andContext","isCtxDependent","altsets","getAlts","dumpDeadEndConfigs","nvae","decs","getDeadEndConfigs","neg","error","exact","./../ParserRuleContext","./../RuleContext","./PredictionMode","28","dup","hasConflictingAltSet","hasStateAssociatedWithOneAlt","hasNonConflictingAltSet","all","configToAlts","getStateToAltMap","minAlt","29","Predicate","PrecedencePredicate","AND","operands","opnds","precedencePredicates","filterPrecedencePredicates","reduced","OR","sort","compareTo","differs","evaluated","30","label_","makeLabel","ruleStart","serializationTypes","minVocabSymbol","maxVocabSymbol","31","./ATNDeserializer","./LexerATNSimulator","./ParserATNSimulator","32","DFAStatesSet","DFA","_states","DFASerializer","LexerDFASerializer","precedenceState","sortedStates","list","serializer","./../atn/ATNConfigSet","./DFASerializer","./DFAState","33","buf","getStateString","getEdgeLabel","baseStateStr","34","getAltSet","35","./DFA","36","DiagnosticErrorListener","exactOnly","ErrorListener","recognizer","getDecisionDescription","reportedAlts","./ErrorListener","37","delegates","offendingSymbol","38","ErrorStrategy","errorRecoveryMode","lastErrorIndex","lastErrorStates","BailErrorStrategy","Errors","InputMismatchException","FailedPredicateException","ParseCancellationException","reportError","endErrorCondition","beginErrorCondition","reportNoViableAlternative","reportInputMismatch","reportFailedPredicate","getMessage","followSet","getErrorRecoverySet","consumeUntil","la","singleTokenDeletion","reportUnwantedToken","expecting","whatFollowsLoopIterationOrRule","startToken","escapeWSAndQuote","reportMissingToken","matchedSymbol","singleTokenInsertion","getMissingSymbol","currentSymbolType","currentState","expectingAtLL2","nextTokenType","tokenText","currentSymbol","expectedTokenType","current","lookback","recoverSet","follow","./../atn/ATNState","./Errors","39","RecognitionException","captureStackTrace","offendingState","deadEndConfigs","predicate","formatMessage","predicateIndex","./../atn/Transition","40","./DiagnosticErrorListener","./ErrorStrategy","41","tree","./CommonTokenStream","./FileStream","./Parser","./ParserRuleContext","./atn/index","./dfa/index","./error/index","./tree/index","42","SyntaxTree","ParseTree","ErrorNode","ParseTreeVisitor","ParseTreeWalker","visit","self","visitAtom","visitErrorNode","funcName","getSymbol","isErrorNode","walk","errorNode","../Utils.js","43","getNodeText","res","getChildren","getAncestors","ancestors","findAllTokenNodes","findAllNodes","findAllRuleNodes","findTokens","nodes","_findAllNodes","descendants","./../atn/ATN","./Tree","44","./Trees","45","46","Smack","./compiler.js","47","antlr4","SmackLexer","SmackParser","compilers","stdlib","g","createUnit","smkSource","targetSource","pack","funcNames","methodContext","packParts","packAbr","getParseTree","chars","smkFile","initMethodContext","extend","getPackageParts","packageDecl","validatePackageExists","createPackage","removePackage","compileSmkFile","format","eval","./compilers","./general","./smack/SmackLexer","./smack/SmackParser","./stdlib","48","jsGenerators","getIds","dottedId","ids","Id","compilePackageDecl","generatePackageDecl","compileComment","generateComment","compileValue","generateValue","compileResolvable","ValueContext","JsonPathContext","compileJsonPath","FuncInvokeContext","compileFuncInvoke","compileKeyRef","resolvablePart","resolvable","generateKeyRef","keyRefParts","keyRef","generateJsonPath","compileExpression","AtomExprContext","SignedExprContext","generateSignedExpr","expression","NotExprContext","generateNotExpr","ParenExprContext","generateParenExpr","expr1Part","expr2Part","SumExprContext","isPos","Minus","generatePlusExpr","generateMinusExpr","PowExprContext","generateSignedPowExpr","generatePowExpr","MulExprContext","generateMulExpr","DivExprContext","generateDivExpr","ModExprContext","generateModExpr","EqExprContext","generateEqExpr","NeqExprContext","generateNeqExpr","LtExprContext","generateLtExpr","LeExprContext","generateLeExpr","GtExprContext","generateGtExpr","GeExprContext","generateGeExpr","AndExprContext","generateAndExpr","OrExprContext","generateOrExpr","compileVarAssign","jsonPathRes","jsonPath","expressionPart","generateVarAssign","resolvableParts","generateFuncInvoke","compileRetStatement","generateRetStatement","compileStatement","statement","VarAssignContext","RetStatementContext","generateClosedStatement","compileLoop","codeBlockPart","compileCodeBlock","codeBlock","generateLoop","compileElseStat","generateElseStat","compileElseIfStat","generateElseIfStat","compileIfStat","elseifStatParts","elseIfStat","elseStatPart","elseStat","generateIfStat","compileSentence","sentence","StatementContext","LoopContext","IfStatContext","sentenceParts","generateCodeBlock","compileFuncDecl","CodeBlockContext","generateFuncDecl","funcDeclParts","FuncDeclContext","smkFileResult","generateSmkFile","./jsGenerators","49","arrayFromArgs","args","ary","curObj","_f","curKey","getPackage","newCompileResult","arguments","Array","moveParentScopeUpstream","newParentScope","getParentScope","_parentScopes","pcs","copyAll","from","hasOwnProperty","setToParent","addToParent","parts","w","50","ncr","generateDottedId","openStatPart","generateVarDecl","jsonPathPart","generateVarDecls","jsonPathParts","cr","idMap","isSimple","valueStr","sentenceSources","addVarDecls","funcPath","noPackageErr","functionExistsErr","varDecl","51","decisionsToDFA","serializedATN","ds","T__0","T__1","T__2","T__3","T__4","T__5","T__6","T__7","T__8","T__9","T__10","T__11","T__12","T__13","T__14","T__15","T__16","T__17","T__18","T__19","Pow","Mul","Div","Mod","Plus","Not","Eq","Neq","Lt","Le","Gt","Ge","And","Or","Comment","WS","STRING","NUMBER","modeNames","grammarFileName","52","SmackListener","enterSmkFile","exitSmkFile","enterPackageDecl","exitPackageDecl","enterVarAssign","exitVarAssign","enterFuncDecl","exitFuncDecl","enterFuncInvoke","exitFuncInvoke","enterJsonPath","exitJsonPath","enterDottedId","exitDottedId","enterKeyRef","exitKeyRef","enterRetStatement","exitRetStatement","enterIfStat","exitIfStat","enterElseIfStat","exitElseIfStat","enterElseStat","exitElseStat","enterLoop","exitLoop","enterSignedExpr","exitSignedExpr","enterGeExpr","exitGeExpr","enterModExpr","exitModExpr","enterGtExpr","exitGtExpr","enterAtomExpr","exitAtomExpr","enterOrExpr","exitOrExpr","enterParenExpr","exitParenExpr","enterNeqExpr","exitNeqExpr","enterEqExpr","exitEqExpr","enterLtExpr","exitLtExpr","enterNotExpr","exitNotExpr","enterSumExpr","exitSumExpr","enterLeExpr","exitLeExpr","enterMulExpr","exitMulExpr","enterDivExpr","exitDivExpr","enterPowExpr","exitPowExpr","enterAndExpr","exitAndExpr","enterResolvable","exitResolvable","enterCodeBlock","exitCodeBlock","enterSentence","exitSentence","enterStatement","exitStatement","enterJson","exitJson","enterObject","exitObject","enterPair","exitPair","enterArray","exitArray","enterValue","exitValue","53","SmkFileContext","RULE_smkFile","PackageDeclContext","RULE_packageDecl","RULE_varAssign","RULE_funcDecl","RULE_funcInvoke","RULE_jsonPath","DottedIdContext","RULE_dottedId","KeyRefContext","RULE_keyRef","RULE_retStatement","RULE_ifStat","ElseIfStatContext","RULE_elseIfStat","ElseStatContext","RULE_elseStat","RULE_loop","ExpressionContext","RULE_expression","ResolvableContext","RULE_resolvable","RULE_codeBlock","SentenceContext","RULE_sentence","RULE_statement","JsonContext","RULE_json","ObjectContext","RULE_object","PairContext","RULE_pair","ArrayContext","RULE_array","RULE_value","SmackVisitor","funcDecl","visitSmkFile","_la","visitPackageDecl","visitVarAssign","varAssign","visitFuncDecl","visitFuncInvoke","funcInvoke","visitJsonPath","_alt","visitDottedId","visitKeyRef","visitRetStatement","retStatement","visitIfStat","ifStat","visitElseIfStat","visitElseStat","visitLoop","loop","visitSignedExpr","visitGeExpr","visitModExpr","visitGtExpr","visitAtomExpr","visitOrExpr","visitParenExpr","visitNeqExpr","visitEqExpr","visitLtExpr","visitNotExpr","visitSumExpr","visitLeExpr","visitMulExpr","visitDivExpr","visitPowExpr","visitAndExpr","_p","_parentctx","_parentState","_prevctx","_startState","la_","visitResolvable","visitCodeBlock","visitSentence","visitStatement","object","array","visitJson","json","visitObject","visitPair","visitArray","visitValue","expression_sempred","./SmackListener","./SmackVisitor","54","55","mc","exec","func","callString","wait","millis"],"mappings":"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","file":"smack-compiler-min.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n// This implementation of {@link TokenStream} loads tokens from a\n// {@link TokenSource} on-demand, and places the tokens in a buffer to provide\n// access to any previous token by index.\n//\n// <p>\n// This token stream ignores the value of {@link Token//getChannel}. If your\n// parser requires the token stream filter tokens to only those on a particular\n// channel, such as {@link Token//DEFAULT_CHANNEL} or\n// {@link Token//HIDDEN_CHANNEL}, use a filtering token stream such a\n// {@link CommonTokenStream}.</p>\n\nvar Token = require('./Token').Token;\nvar Lexer = require('./Lexer').Lexer;\nvar Interval = require('./IntervalSet').Interval;\n\n// this is just to keep meaningful parameter types to Parser\nfunction TokenStream() {\n\treturn this;\n}\n\nfunction BufferedTokenStream(tokenSource) {\n\n\tTokenStream.call(this);\n\t// The {@link TokenSource} from which tokens for this stream are fetched.\n\tthis.tokenSource = tokenSource;\n\n\t// A collection of all tokens fetched from the token source. The list is\n\t// considered a complete view of the input once {@link //fetchedEOF} is set\n\t// to {@code true}.\n\tthis.tokens = [];\n\n\t// The index into {@link //tokens} of the current token (next token to\n\t// {@link //consume}). {@link //tokens}{@code [}{@link //p}{@code ]} should\n\t// be\n\t// {@link //LT LT(1)}.\n\t//\n\t// <p>This field is set to -1 when the stream is first constructed or when\n\t// {@link //setTokenSource} is called, indicating that the first token has\n\t// not yet been fetched from the token source. For additional information,\n\t// see the documentation of {@link IntStream} for a description of\n\t// Initializing Methods.</p>\n\tthis.index = -1;\n\n\t// Indicates whether the {@link Token//EOF} token has been fetched from\n\t// {@link //tokenSource} and added to {@link //tokens}. This field improves\n\t// performance for the following cases:\n\t//\n\t// <ul>\n\t// <li>{@link //consume}: The lookahead check in {@link //consume} to\n\t// prevent\n\t// consuming the EOF symbol is optimized by checking the values of\n\t// {@link //fetchedEOF} and {@link //p} instead of calling {@link\n\t// //LA}.</li>\n\t// <li>{@link //fetch}: The check to prevent adding multiple EOF symbols\n\t// into\n\t// {@link //tokens} is trivial with this field.</li>\n\t// <ul>\n\tthis.fetchedEOF = false;\n\treturn this;\n}\n\nBufferedTokenStream.prototype = Object.create(TokenStream.prototype);\nBufferedTokenStream.prototype.constructor = BufferedTokenStream;\n\nBufferedTokenStream.prototype.mark = function() {\n\treturn 0;\n};\n\nBufferedTokenStream.prototype.release = function(marker) {\n\t// no resources to release\n};\n\nBufferedTokenStream.prototype.reset = function() {\n\tthis.seek(0);\n};\n\nBufferedTokenStream.prototype.seek = function(index) {\n\tthis.lazyInit();\n\tthis.index = this.adjustSeekIndex(index);\n};\n\nBufferedTokenStream.prototype.get = function(index) {\n\tthis.lazyInit();\n\treturn this.tokens[index];\n};\n\nBufferedTokenStream.prototype.consume = function() {\n\tvar skipEofCheck = false;\n\tif (this.index >= 0) {\n\t\tif (this.fetchedEOF) {\n\t\t\t// the last token in tokens is EOF. skip check if p indexes any\n\t\t\t// fetched token except the last.\n\t\t\tskipEofCheck = this.index < this.tokens.length - 1;\n\t\t} else {\n\t\t\t// no EOF token in tokens. skip check if p indexes a fetched token.\n\t\t\tskipEofCheck = this.index < this.tokens.length;\n\t\t}\n\t} else {\n\t\t// not yet initialized\n\t\tskipEofCheck = false;\n\t}\n\tif (!skipEofCheck && this.LA(1) === Token.EOF) {\n\t\tthrow \"cannot consume EOF\";\n\t}\n\tif (this.sync(this.index + 1)) {\n\t\tthis.index = this.adjustSeekIndex(this.index + 1);\n\t}\n};\n\n// Make sure index {@code i} in tokens has a token.\n//\n// @return {@code true} if a token is located at index {@code i}, otherwise\n// {@code false}.\n// @see //get(int i)\n// /\nBufferedTokenStream.prototype.sync = function(i) {\n\tvar n = i - this.tokens.length + 1; // how many more elements we need?\n\tif (n > 0) {\n\t\tvar fetched = this.fetch(n);\n\t\treturn fetched >= n;\n\t}\n\treturn true;\n};\n\n// Add {@code n} elements to buffer.\n//\n// @return The actual number of elements added to the buffer.\n// /\nBufferedTokenStream.prototype.fetch = function(n) {\n\tif (this.fetchedEOF) {\n\t\treturn 0;\n\t}\n\tfor (var i = 0; i < n; i++) {\n\t\tvar t = this.tokenSource.nextToken();\n\t\tt.tokenIndex = this.tokens.length;\n\t\tthis.tokens.push(t);\n\t\tif (t.type === Token.EOF) {\n\t\t\tthis.fetchedEOF = true;\n\t\t\treturn i + 1;\n\t\t}\n\t}\n\treturn n;\n};\n\n// Get all tokens from start..stop inclusively///\nBufferedTokenStream.prototype.getTokens = function(start, stop, types) {\n\tif (types === undefined) {\n\t\ttypes = null;\n\t}\n\tif (start < 0 || stop < 0) {\n\t\treturn null;\n\t}\n\tthis.lazyInit();\n\tvar subset = [];\n\tif (stop >= this.tokens.length) {\n\t\tstop = this.tokens.length - 1;\n\t}\n\tfor (var i = start; i < stop; i++) {\n\t\tvar t = this.tokens[i];\n\t\tif (t.type === Token.EOF) {\n\t\t\tbreak;\n\t\t}\n\t\tif (types === null || types.contains(t.type)) {\n\t\t\tsubset.push(t);\n\t\t}\n\t}\n\treturn subset;\n};\n\nBufferedTokenStream.prototype.LA = function(i) {\n\treturn this.LT(i).type;\n};\n\nBufferedTokenStream.prototype.LB = function(k) {\n\tif (this.index - k < 0) {\n\t\treturn null;\n\t}\n\treturn this.tokens[this.index - k];\n};\n\nBufferedTokenStream.prototype.LT = function(k) {\n\tthis.lazyInit();\n\tif (k === 0) {\n\t\treturn null;\n\t}\n\tif (k < 0) {\n\t\treturn this.LB(-k);\n\t}\n\tvar i = this.index + k - 1;\n\tthis.sync(i);\n\tif (i >= this.tokens.length) { // return EOF token\n\t\t// EOF must be last token\n\t\treturn this.tokens[this.tokens.length - 1];\n\t}\n\treturn this.tokens[i];\n};\n\n// Allowed derived classes to modify the behavior of operations which change\n// the current stream position by adjusting the target token index of a seek\n// operation. The default implementation simply returns {@code i}. If an\n// exception is thrown in this method, the current stream index should not be\n// changed.\n//\n// <p>For example, {@link CommonTokenStream} overrides this method to ensure\n// that\n// the seek target is always an on-channel token.</p>\n//\n// @param i The target token index.\n// @return The adjusted target token index.\n\nBufferedTokenStream.prototype.adjustSeekIndex = function(i) {\n\treturn i;\n};\n\nBufferedTokenStream.prototype.lazyInit = function() {\n\tif (this.index === -1) {\n\t\tthis.setup();\n\t}\n};\n\nBufferedTokenStream.prototype.setup = function() {\n\tthis.sync(0);\n\tthis.index = this.adjustSeekIndex(0);\n};\n\n// Reset this token stream by setting its token source.///\nBufferedTokenStream.prototype.setTokenSource = function(tokenSource) {\n\tthis.tokenSource = tokenSource;\n\tthis.tokens = [];\n\tthis.index = -1;\n};\n\n\n// Given a starting index, return the index of the next token on channel.\n// Return i if tokens[i] is on channel. Return -1 if there are no tokens\n// on channel between i and EOF.\n// /\nBufferedTokenStream.prototype.nextTokenOnChannel = function(i, channel) {\n\tthis.sync(i);\n\tif (i >= this.tokens.length) {\n\t\treturn -1;\n\t}\n\tvar token = this.tokens[i];\n\twhile (token.channel !== this.channel) {\n\t\tif (token.type === Token.EOF) {\n\t\t\treturn -1;\n\t\t}\n\t\ti += 1;\n\t\tthis.sync(i);\n\t\ttoken = this.tokens[i];\n\t}\n\treturn i;\n};\n\n// Given a starting index, return the index of the previous token on channel.\n// Return i if tokens[i] is on channel. Return -1 if there are no tokens\n// on channel between i and 0.\nBufferedTokenStream.prototype.previousTokenOnChannel = function(i, channel) {\n\twhile (i >= 0 && this.tokens[i].channel !== channel) {\n\t\ti -= 1;\n\t}\n\treturn i;\n};\n\n// Collect all tokens on specified channel to the right of\n// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL or\n// EOF. If channel is -1, find any non default channel token.\nBufferedTokenStream.prototype.getHiddenTokensToRight = function(tokenIndex,\n\t\tchannel) {\n\tif (channel === undefined) {\n\t\tchannel = -1;\n\t}\n\tthis.lazyInit();\n\tif (tokenIndex < 0 || tokenIndex >= this.tokens.length) {\n\t\tthrow \"\" + tokenIndex + \" not in 0..\" + this.tokens.length - 1;\n\t}\n\tvar nextOnChannel = this.nextTokenOnChannel(tokenIndex + 1,\n\t\t\tLexer.DEFAULT_TOKEN_CHANNEL);\n\tvar from_ = tokenIndex + 1;\n\t// if none onchannel to right, nextOnChannel=-1 so set to = last token\n\tvar to = nextOnChannel === -1 ? this.tokens.length - 1 : nextOnChannel;\n\treturn this.filterForChannel(from_, to, channel);\n};\n\n// Collect all tokens on specified channel to the left of\n// the current token up until we see a token on DEFAULT_TOKEN_CHANNEL.\n// If channel is -1, find any non default channel token.\nBufferedTokenStream.prototype.getHiddenTokensToLeft = function(tokenIndex,\n\t\tchannel) {\n\tif (channel === undefined) {\n\t\tchannel = -1;\n\t}\n\tthis.lazyInit();\n\tif (tokenIndex < 0 || tokenIndex >= this.tokens.length) {\n\t\tthrow \"\" + tokenIndex + \" not in 0..\" + this.tokens.length - 1;\n\t}\n\tvar prevOnChannel = this.previousTokenOnChannel(tokenIndex - 1,\n\t\t\tLexer.DEFAULT_TOKEN_CHANNEL);\n\tif (prevOnChannel === tokenIndex - 1) {\n\t\treturn null;\n\t}\n\t// if none on channel to left, prevOnChannel=-1 then from=0\n\tvar from_ = prevOnChannel + 1;\n\tvar to = tokenIndex - 1;\n\treturn this.filterForChannel(from_, to, channel);\n};\n\nBufferedTokenStream.prototype.filterForChannel = function(left, right, channel) {\n\tvar hidden = [];\n\tfor (var i = left; i < right + 1; i++) {\n\t\tvar t = this.tokens[i];\n\t\tif (channel === -1) {\n\t\t\tif (t.channel !== Lexer.DEFAULT_TOKEN_CHANNEL) {\n\t\t\t\thidden.push(t);\n\t\t\t}\n\t\t} else if (t.channel === channel) {\n\t\t\thidden.push(t);\n\t\t}\n\t}\n\tif (hidden.length === 0) {\n\t\treturn null;\n\t}\n\treturn hidden;\n};\n\nBufferedTokenStream.prototype.getSourceName = function() {\n\treturn this.tokenSource.getSourceName();\n};\n\n// Get the text of all tokens in this buffer.///\nBufferedTokenStream.prototype.getText = function(interval) {\n\tthis.lazyInit();\n\tthis.fill();\n\tif (interval === undefined || interval === null) {\n\t\tinterval = new Interval(0, this.tokens.length - 1);\n\t}\n\tvar start = interval.start;\n\tif (start instanceof Token) {\n\t\tstart = start.tokenIndex;\n\t}\n\tvar stop = interval.stop;\n\tif (stop instanceof Token) {\n\t\tstop = stop.tokenIndex;\n\t}\n\tif (start === null || stop === null || start < 0 || stop < 0) {\n\t\treturn \"\";\n\t}\n\tif (stop >= this.tokens.length) {\n\t\tstop = this.tokens.length - 1;\n\t}\n\tvar s = \"\";\n\tfor (var i = start; i < stop + 1; i++) {\n\t\tvar t = this.tokens[i];\n\t\tif (t.type === Token.EOF) {\n\t\t\tbreak;\n\t\t}\n\t\ts = s + t.text;\n\t}\n\treturn s;\n};\n\n// Get all tokens from lexer until EOF///\nBufferedTokenStream.prototype.fill = function() {\n\tthis.lazyInit();\n\twhile (this.fetch(1000) === 1000) {\n\t\tcontinue;\n\t}\n};\n\nexports.BufferedTokenStream = BufferedTokenStream;\n\n},{\"./IntervalSet\":6,\"./Lexer\":8,\"./Token\":14}],2:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n//\n// This default implementation of {@link TokenFactory} creates\n// {@link CommonToken} objects.\n//\n\nvar CommonToken = require('./Token').CommonToken;\n\nfunction TokenFactory() {\n\treturn this;\n}\n\nfunction CommonTokenFactory(copyText) {\n\tTokenFactory.call(this);\n    // Indicates whether {@link CommonToken//setText} should be called after\n    // constructing tokens to explicitly set the text. This is useful for cases\n    // where the input stream might not be able to provide arbitrary substrings\n    // of text from the input after the lexer creates a token (e.g. the\n    // implementation of {@link CharStream//getText} in\n    // {@link UnbufferedCharStream} throws an\n    // {@link UnsupportedOperationException}). Explicitly setting the token text\n    // allows {@link Token//getText} to be called at any time regardless of the\n    // input stream implementation.\n    //\n    // <p>\n    // The default value is {@code false} to avoid the performance and memory\n    // overhead of copying text for every token unless explicitly requested.</p>\n    //\n    this.copyText = copyText===undefined ? false : copyText;\n\treturn this;\n}\n\nCommonTokenFactory.prototype = Object.create(TokenFactory.prototype);\nCommonTokenFactory.prototype.constructor = CommonTokenFactory;\n\n//\n// The default {@link CommonTokenFactory} instance.\n//\n// <p>\n// This token factory does not explicitly copy token text when constructing\n// tokens.</p>\n//\nCommonTokenFactory.DEFAULT = new CommonTokenFactory();\n\nCommonTokenFactory.prototype.create = function(source, type, text, channel, start, stop, line, column) {\n    var t = new CommonToken(source, type, channel, start, stop);\n    t.line = line;\n    t.column = column;\n    if (text !==null) {\n        t.text = text;\n    } else if (this.copyText && source[1] !==null) {\n        t.text = source[1].getText(start,stop);\n    }\n    return t;\n};\n\nCommonTokenFactory.prototype.createThin = function(type, text) {\n    var t = new CommonToken(null, type);\n    t.text = text;\n    return t;\n};\n\nexports.CommonTokenFactory = CommonTokenFactory;\n\n},{\"./Token\":14}],3:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n//\n// This class extends {@link BufferedTokenStream} with functionality to filter\n// token streams to tokens on a particular channel (tokens where\n// {@link Token//getChannel} returns a particular value).\n//\n// <p>\n// This token stream provides access to all tokens by index or when calling\n// methods like {@link //getText}. The channel filtering is only used for code\n// accessing tokens via the lookahead methods {@link //LA}, {@link //LT}, and\n// {@link //LB}.</p>\n//\n// <p>\n// By default, tokens are placed on the default channel\n// ({@link Token//DEFAULT_CHANNEL}), but may be reassigned by using the\n// {@code ->channel(HIDDEN)} lexer command, or by using an embedded action to\n// call {@link Lexer//setChannel}.\n// </p>\n//\n// <p>\n// Note: lexer rules which use the {@code ->skip} lexer command or call\n// {@link Lexer//skip} do not produce tokens at all, so input text matched by\n// such a rule will not be available as part of the token stream, regardless of\n// channel.</p>\n///\n\nvar Token = require('./Token').Token;\nvar BufferedTokenStream = require('./BufferedTokenStream').BufferedTokenStream;\n\nfunction CommonTokenStream(lexer, channel) {\n\tBufferedTokenStream.call(this, lexer);\n    this.channel = channel===undefined ? Token.DEFAULT_CHANNEL : channel;\n    return this;\n}\n\nCommonTokenStream.prototype = Object.create(BufferedTokenStream.prototype);\nCommonTokenStream.prototype.constructor = CommonTokenStream;\n\nCommonTokenStream.prototype.adjustSeekIndex = function(i) {\n    return this.nextTokenOnChannel(i, this.channel);\n};\n\nCommonTokenStream.prototype.LB = function(k) {\n    if (k===0 || this.index-k<0) {\n        return null;\n    }\n    var i = this.index;\n    var n = 1;\n    // find k good tokens looking backwards\n    while (n <= k) {\n        // skip off-channel tokens\n        i = this.previousTokenOnChannel(i - 1, this.channel);\n        n += 1;\n    }\n    if (i < 0) {\n        return null;\n    }\n    return this.tokens[i];\n};\n\nCommonTokenStream.prototype.LT = function(k) {\n    this.lazyInit();\n    if (k === 0) {\n        return null;\n    }\n    if (k < 0) {\n        return this.LB(-k);\n    }\n    var i = this.index;\n    var n = 1; // we know tokens[pos] is a good one\n    // find k good tokens\n    while (n < k) {\n        // skip off-channel tokens, but make sure to not look past EOF\n        if (this.sync(i + 1)) {\n            i = this.nextTokenOnChannel(i + 1, this.channel);\n        }\n        n += 1;\n    }\n    return this.tokens[i];\n};\n\n// Count EOF just once.///\nCommonTokenStream.prototype.getNumberOfOnChannelTokens = function() {\n    var n = 0;\n    this.fill();\n    for (var i =0; i< this.tokens.length;i++) {\n        var t = this.tokens[i];\n        if( t.channel===this.channel) {\n            n += 1;\n        }\n        if( t.type===Token.EOF) {\n            break;\n        }\n    }\n    return n;\n};\n\nexports.CommonTokenStream = CommonTokenStream;\n},{\"./BufferedTokenStream\":1,\"./Token\":14}],4:[function(require,module,exports){\n//\n//  [The \"BSD license\"]\n//   Copyright (c) 2012 Terence Parr\n//   Copyright (c) 2012 Sam Harwell\n//   Copyright (c) 2014 Eric Vergnaud\n//   All rights reserved.\n// \n//   Redistribution and use in source and binary forms, with or without\n//   modification, are permitted provided that the following conditions\n//   are met:\n// \n//   1. Redistributions of source code must retain the above copyright\n//      notice, this list of conditions and the following disclaimer.\n//   2. Redistributions in binary form must reproduce the above copyright\n//      notice, this list of conditions and the following disclaimer in the\n//      documentation and/or other materials provided with the distribution.\n//   3. The name of the author may not be used to endorse or promote products\n//      derived from this software without specific prior written permission.\n// \n//   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//   IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n// \n\n//\n//  This is an InputStream that is loaded from a file all at once\n//  when you construct the object.\n// \nvar InputStream = require('./InputStream').InputStream;\nvar isNodeJs = typeof window === 'undefined' && typeof importScripts === 'undefined';\nvar fs = isNodeJs ? require(\"fs\") : null;\n\nfunction FileStream(fileName) {\n\tvar data = fs.readFileSync(fileName, \"utf8\");\n\tInputStream.call(this, data);\n\tthis.fileName = fileName;\n\treturn this;\n}\n\nFileStream.prototype = Object.create(InputStream.prototype);\nFileStream.prototype.constructor = FileStream;\n\nexports.FileStream = FileStream;\n\n},{\"./InputStream\":5,\"fs\":45}],5:[function(require,module,exports){\n// \n//  [The \"BSD license\"]\n//   Copyright (c) 2012 Terence Parr\n//   Copyright (c) 2012 Sam Harwell\n//   Copyright (c) 2014 Eric Vergnaud\n//   All rights reserved.\n// \n//   Redistribution and use in source and binary forms, with or without\n//   modification, are permitted provided that the following conditions\n//   are met:\n// \n//   1. Redistributions of source code must retain the above copyright\n//      notice, this list of conditions and the following disclaimer.\n//   2. Redistributions in binary form must reproduce the above copyright\n//      notice, this list of conditions and the following disclaimer in the\n//      documentation and/or other materials provided with the distribution.\n//   3. The name of the author may not be used to endorse or promote products\n//      derived from this software without specific prior written permission.\n// \n//   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//   IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n// \n\nvar Token = require('./Token').Token;\n\n// Vacuum all input from a string and then treat it like a buffer.\n\nfunction _loadString(stream) {\n\tstream._index = 0;\n\tstream.data = [];\n\tfor (var i = 0; i < stream.strdata.length; i++) {\n\t\tstream.data.push(stream.strdata.charCodeAt(i));\n\t}\n\tstream._size = stream.data.length;\n}\n\nfunction InputStream(data) {\n\tthis.name = \"<empty>\";\n\tthis.strdata = data;\n\t_loadString(this);\n\treturn this;\n}\n\nObject.defineProperty(InputStream.prototype, \"index\", {\n\tget : function() {\n\t\treturn this._index;\n\t}\n});\n\nObject.defineProperty(InputStream.prototype, \"size\", {\n\tget : function() {\n\t\treturn this._size;\n\t}\n});\n\n// Reset the stream so that it's in the same state it was\n// when the object was created *except* the data array is not\n// touched.\n//\nInputStream.prototype.reset = function() {\n\tthis._index = 0;\n};\n\nInputStream.prototype.consume = function() {\n\tif (this._index >= this._size) {\n\t\t// assert this.LA(1) == Token.EOF\n\t\tthrow (\"cannot consume EOF\");\n\t}\n\tthis._index += 1;\n};\n\nInputStream.prototype.LA = function(offset) {\n\tif (offset === 0) {\n\t\treturn 0; // undefined\n\t}\n\tif (offset < 0) {\n\t\toffset += 1; // e.g., translate LA(-1) to use offset=0\n\t}\n\tvar pos = this._index + offset - 1;\n\tif (pos < 0 || pos >= this._size) { // invalid\n\t\treturn Token.EOF;\n\t}\n\treturn this.data[pos];\n};\n\nInputStream.prototype.LT = function(offset) {\n\treturn this.LA(offset);\n};\n\n// mark/release do nothing; we have entire buffer\nInputStream.prototype.mark = function() {\n\treturn -1;\n};\n\nInputStream.prototype.release = function(marker) {\n};\n\n// consume() ahead until p==_index; can't just set p=_index as we must\n// update line and column. If we seek backwards, just set p\n//\nInputStream.prototype.seek = function(_index) {\n\tif (_index <= this._index) {\n\t\tthis._index = _index; // just jump; don't update stream state (line,\n\t\t\t\t\t\t\t\t// ...)\n\t\treturn;\n\t}\n\t// seek forward\n\tthis._index = Math.min(_index, this._size);\n};\n\nInputStream.prototype.getText = function(start, stop) {\n\tif (stop >= this._size) {\n\t\tstop = this._size - 1;\n\t}\n\tif (start >= this._size) {\n\t\treturn \"\";\n\t} else {\n\t\treturn this.strdata.slice(start, stop + 1);\n\t}\n};\n\nInputStream.prototype.toString = function() {\n\treturn this.strdata;\n};\n\nexports.InputStream = InputStream;\n\n},{\"./Token\":14}],6:[function(require,module,exports){\n/*jslint smarttabs:true */\n\nvar Token = require('./Token').Token;\n\n/* stop is not included! */\nfunction Interval(start, stop) {\n\tthis.start = start;\n\tthis.stop = stop;\n\treturn this;\n}\n\nInterval.prototype.contains = function(item) {\n\treturn item >= this.start && item < this.stop;\n};\n\nInterval.prototype.toString = function() {\n\tif(this.start===this.stop-1) {\n\t\treturn this.start.toString();\n\t} else {\n\t\treturn this.start.toString() + \"..\" + (this.stop-1).toString();\n\t}\n};\n\n\nObject.defineProperty(Interval.prototype, \"length\", {\n\tget : function() {\n\t\treturn this.stop - this.start;\n\t}\n});\n\nfunction IntervalSet() {\n\tthis.intervals = null;\n\tthis.readOnly = false;\n}\n\nIntervalSet.prototype.first = function(v) {\n\tif (this.intervals === null || this.intervals.length===0) {\n\t\treturn Token.INVALID_TYPE;\n\t} else {\n\t\treturn this.intervals[0].start;\n\t}\n};\n\nIntervalSet.prototype.addOne = function(v) {\n\tthis.addInterval(new Interval(v, v + 1));\n};\n\nIntervalSet.prototype.addRange = function(l, h) {\n\tthis.addInterval(new Interval(l, h + 1));\n};\n\nIntervalSet.prototype.addInterval = function(v) {\n\tif (this.intervals === null) {\n\t\tthis.intervals = [];\n\t\tthis.intervals.push(v);\n\t} else {\n\t\t// find insert pos\n\t\tfor (var k = 0; k < this.intervals.length; k++) {\n\t\t\tvar i = this.intervals[k];\n\t\t\t// distinct range -> insert\n\t\t\tif (v.stop < i.start) {\n\t\t\t\tthis.intervals.splice(k, 0, v);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// contiguous range -> adjust\n\t\t\telse if (v.stop === i.start) {\n\t\t\t\tthis.intervals[k].start = v.start;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// overlapping range -> adjust and reduce\n\t\t\telse if (v.start <= i.stop) {\n\t\t\t\tthis.intervals[k] = new Interval(Math.min(i.start, v.start), Math.max(i.stop, v.stop));\n\t\t\t\tthis.reduce(k);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\t// greater than any existing\n\t\tthis.intervals.push(v);\n\t}\n};\n\nIntervalSet.prototype.addSet = function(other) {\n\tif (other.intervals !== null) {\n\t\tfor (var k = 0; k < other.intervals.length; k++) {\n\t\t\tvar i = other.intervals[k];\n\t\t\tthis.addInterval(new Interval(i.start, i.stop));\n\t\t}\n\t}\n\treturn this;\n};\n\nIntervalSet.prototype.reduce = function(k) {\n\t// only need to reduce if k is not the last\n\tif (k < this.intervalslength - 1) {\n\t\tvar l = this.intervals[k];\n\t\tvar r = this.intervals[k + 1];\n\t\t// if r contained in l\n\t\tif (l.stop >= r.stop) {\n\t\t\tthis.intervals.pop(k + 1);\n\t\t\tthis.reduce(k);\n\t\t} else if (l.stop >= r.start) {\n\t\t\tthis.intervals[k] = new Interval(l.start, r.stop);\n\t\t\tthis.intervals.pop(k + 1);\n\t\t}\n\t}\n};\n\nIntervalSet.prototype.complement = function(start, stop) {\n    var result = new IntervalSet();\n    result.addInterval(new Interval(start,stop+1));\n    for(var i=0; i<this.intervals.length; i++) {\n        result.removeRange(this.intervals[i]);\n    }\n    return result;\n};\n\nIntervalSet.prototype.contains = function(item) {\n\tif (this.intervals === null) {\n\t\treturn false;\n\t} else {\n\t\tfor (var k = 0; k < this.intervals.length; k++) {\n\t\t\tif(this.intervals[k].contains(item)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n};\n\nObject.defineProperty(IntervalSet.prototype, \"length\", {\n\tget : function() {\n\t\tvar len = 0;\n\t\tthis.intervals.map(function(i) {len += i.length;});\n\t\treturn len;\n\t}\n});\n\nIntervalSet.prototype.removeRange = function(v) {\n    if(v.start===v.stop-1) {\n        this.removeOne(v.start);\n    } else if (this.intervals!==null) {\n        var k = 0;\n        for(var n=0; n<this.intervals.length; n++) {\n            var i = this.intervals[k];\n            // intervals are ordered\n            if (v.stop<=i.start) {\n                return;\n            }\n            // check for including range, split it\n            else if(v.start>i.start && v.stop<i.stop) {\n                this.intervals[k] = new Interval(i.start, v.start);\n                var x = new Interval(v.stop, i.stop);\n                this.intervals.splice(k, 0, x);\n                return;\n            }\n            // check for included range, remove it\n            else if(v.start<=i.start && v.stop>=i.stop) {\n                this.intervals.splice(k, 1);\n                k = k - 1; // need another pass\n            }\n            // check for lower boundary\n            else if(v.start<i.stop) {\n                this.intervals[k] = new Interval(i.start, v.start);\n            }\n            // check for upper boundary\n            else if(v.stop<i.stop) {\n                this.intervals[k] = new Interval(v.stop, i.stop);\n            }\n            k += 1;\n        }\n    }\n};\n\nIntervalSet.prototype.removeOne = function(v) {\n\tif (this.intervals !== null) {\n\t\tfor (var k = 0; k < this.intervals.length; k++) {\n\t\t\tvar i = this.intervals[k];\n\t\t\t// intervals is ordered\n\t\t\tif (v < i.start) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// check for single value range\n\t\t\telse if (v === i.start && v === i.stop - 1) {\n\t\t\t\tthis.intervals.splice(k, 1);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// check for lower boundary\n\t\t\telse if (v === i.start) {\n\t\t\t\tthis.intervals[k] = new Interval(i.start + 1, i.stop);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// check for upper boundary\n\t\t\telse if (v === i.stop - 1) {\n\t\t\t\tthis.intervals[k] = new Interval(i.start, i.stop - 1);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t// split existing range\n\t\t\telse if (v < i.stop - 1) {\n\t\t\t\tvar x = new Interval(i.start, v);\n\t\t\t\ti.start = v + 1;\n\t\t\t\tthis.intervals.splice(k, 0, x);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\n};\n\nIntervalSet.prototype.toString = function(literalNames, symbolicNames, elemsAreChar) {\n\tliteralNames = literalNames || null;\n\tsymbolicNames = symbolicNames || null;\n\telemsAreChar = elemsAreChar || false;\n\tif (this.intervals === null) {\n\t\treturn \"{}\";\n\t} else if(literalNames!==null || symbolicNames!==null) {\n\t\treturn this.toTokenString(literalNames, symbolicNames);\n\t} else if(elemsAreChar) {\n\t\treturn this.toCharString();\n\t} else {\n\t\treturn this.toIndexString();\n\t}\n};\n\nIntervalSet.prototype.toCharString = function() {\n\tvar names = [];\n\tfor (var i = 0; i < this.intervals.length; i++) {\n\t\tvar v = this.intervals[i];\n\t\tif(v.stop===v.start+1) {\n\t\t\tif ( v.start===Token.EOF ) {\n\t\t\t\tnames.push(\"<EOF>\");\n\t\t\t} else {\n\t\t\t\tnames.push(\"'\" + String.fromCharCode(v.start) + \"'\");\n\t\t\t}\n\t\t} else {\n\t\t\tnames.push(\"'\" + String.fromCharCode(v.start) + \"'..'\" + String.fromCharCode(v.stop-1) + \"'\");\n\t\t}\n\t}\n\tif (names.length > 1) {\n\t\treturn \"{\" + names.join(\", \") + \"}\";\n\t} else {\n\t\treturn names[0];\n\t}\n};\n\n\nIntervalSet.prototype.toIndexString = function() {\n\tvar names = [];\n\tfor (var i = 0; i < this.intervals.length; i++) {\n\t\tvar v = this.intervals[i];\n\t\tif(v.stop===v.start+1) {\n\t\t\tif ( v.start===Token.EOF ) {\n\t\t\t\tnames.push(\"<EOF>\");\n\t\t\t} else {\n\t\t\t\tnames.push(v.start.toString());\n\t\t\t}\n\t\t} else {\n\t\t\tnames.push(v.start.toString() + \"..\" + (v.stop-1).toString());\n\t\t}\n\t}\n\tif (names.length > 1) {\n\t\treturn \"{\" + names.join(\", \") + \"}\";\n\t} else {\n\t\treturn names[0];\n\t}\n};\n\n\nIntervalSet.prototype.toTokenString = function(literalNames, symbolicNames) {\n\tvar names = [];\n\tfor (var i = 0; i < this.intervals.length; i++) {\n\t\tvar v = this.intervals[i];\n\t\tfor (var j = v.start; j < v.stop; j++) {\n\t\t\tnames.push(this.elementName(literalNames, symbolicNames, j));\n\t\t}\n\t}\n\tif (names.length > 1) {\n\t\treturn \"{\" + names.join(\", \") + \"}\";\n\t} else {\n\t\treturn names[0];\n\t}\n};\n\nIntervalSet.prototype.elementName = function(literalNames, symbolicNames, a) {\n\tif (a === Token.EOF) {\n\t\treturn \"<EOF>\";\n\t} else if (a === Token.EPSILON) {\n\t\treturn \"<EPSILON>\";\n\t} else {\n\t\treturn literalNames[a] || symbolicNames[a];\n\t}\n};\n\nexports.Interval = Interval;\nexports.IntervalSet = IntervalSet;\n\n},{\"./Token\":14}],7:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\nvar Set = require('./Utils').Set;\nvar BitSet = require('./Utils').BitSet;\nvar Token = require('./Token').Token;\nvar ATNConfig = require('./atn/ATNConfig').ATNConfig;\nvar Interval = require('./IntervalSet').Interval;\nvar IntervalSet = require('./IntervalSet').IntervalSet;\nvar RuleStopState = require('./atn/ATNState').RuleStopState;\nvar RuleTransition = require('./atn/Transition').RuleTransition;\nvar NotSetTransition = require('./atn/Transition').NotSetTransition;\nvar WildcardTransition = require('./atn/Transition').WildcardTransition;\nvar AbstractPredicateTransition = require('./atn/Transition').AbstractPredicateTransition;\n\nvar pc = require('./PredictionContext');\nvar predictionContextFromRuleContext = pc.predictionContextFromRuleContext;\nvar PredictionContext = pc.PredictionContext;\nvar SingletonPredictionContext = pc.SingletonPredictionContext;\n\nfunction LL1Analyzer (atn) {\n    this.atn = atn;\n}\n\n//* Special value added to the lookahead sets to indicate that we hit\n//  a predicate during analysis if {@code seeThruPreds==false}.\n///\nLL1Analyzer.HIT_PRED = Token.INVALID_TYPE;\n\n\n//*\n// Calculates the SLL(1) expected lookahead set for each outgoing transition\n// of an {@link ATNState}. The returned array has one element for each\n// outgoing transition in {@code s}. If the closure from transition\n// <em>i</em> leads to a semantic predicate before matching a symbol, the\n// element at index <em>i</em> of the result will be {@code null}.\n//\n// @param s the ATN state\n// @return the expected symbols for each outgoing transition of {@code s}.\n///\nLL1Analyzer.prototype.getDecisionLookahead = function(s) {\n    if (s === null) {\n        return null;\n    }\n    var count = s.transitions.length;\n    var look = [];\n    for(var alt=0; alt< count; alt++) {\n        look[alt] = new IntervalSet();\n        var lookBusy = new Set();\n        var seeThruPreds = false; // fail to get lookahead upon pred\n        this._LOOK(s.transition(alt).target, null, PredictionContext.EMPTY,\n              look[alt], lookBusy, new BitSet(), seeThruPreds, false);\n        // Wipe out lookahead for this alternative if we found nothing\n        // or we had a predicate when we !seeThruPreds\n        if (look[alt].length===0 || look[alt].contains(LL1Analyzer.HIT_PRED)) {\n            look[alt] = null;\n        }\n    }\n    return look;\n};\n\n//*\n// Compute set of tokens that can follow {@code s} in the ATN in the\n// specified {@code ctx}.\n//\n// <p>If {@code ctx} is {@code null} and the end of the rule containing\n// {@code s} is reached, {@link Token//EPSILON} is added to the result set.\n// If {@code ctx} is not {@code null} and the end of the outermost rule is\n// reached, {@link Token//EOF} is added to the result set.</p>\n//\n// @param s the ATN state\n// @param stopState the ATN state to stop at. This can be a\n// {@link BlockEndState} to detect epsilon paths through a closure.\n// @param ctx the complete parser context, or {@code null} if the context\n// should be ignored\n//\n// @return The set of tokens that can follow {@code s} in the ATN in the\n// specified {@code ctx}.\n///\nLL1Analyzer.prototype.LOOK = function(s, stopState, ctx) {\n    var r = new IntervalSet();\n    var seeThruPreds = true; // ignore preds; get all lookahead\n\tctx = ctx || null;\n    var lookContext = ctx!==null ? predictionContextFromRuleContext(s.atn, ctx) : null;\n    this._LOOK(s, stopState, lookContext, r, new Set(), new BitSet(), seeThruPreds, true);\n    return r;\n};\n    \n//*\n// Compute set of tokens that can follow {@code s} in the ATN in the\n// specified {@code ctx}.\n//\n// <p>If {@code ctx} is {@code null} and {@code stopState} or the end of the\n// rule containing {@code s} is reached, {@link Token//EPSILON} is added to\n// the result set. If {@code ctx} is not {@code null} and {@code addEOF} is\n// {@code true} and {@code stopState} or the end of the outermost rule is\n// reached, {@link Token//EOF} is added to the result set.</p>\n//\n// @param s the ATN state.\n// @param stopState the ATN state to stop at. This can be a\n// {@link BlockEndState} to detect epsilon paths through a closure.\n// @param ctx The outer context, or {@code null} if the outer context should\n// not be used.\n// @param look The result lookahead set.\n// @param lookBusy A set used for preventing epsilon closures in the ATN\n// from causing a stack overflow. Outside code should pass\n// {@code new Set<ATNConfig>} for this argument.\n// @param calledRuleStack A set used for preventing left recursion in the\n// ATN from causing a stack overflow. Outside code should pass\n// {@code new BitSet()} for this argument.\n// @param seeThruPreds {@code true} to true semantic predicates as\n// implicitly {@code true} and \"see through them\", otherwise {@code false}\n// to treat semantic predicates as opaque and add {@link //HIT_PRED} to the\n// result if one is encountered.\n// @param addEOF Add {@link Token//EOF} to the result if the end of the\n// outermost context is reached. This parameter has no effect if {@code ctx}\n// is {@code null}.\n///\nLL1Analyzer.prototype._LOOK = function(s, stopState , ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF) {\n    var c = new ATNConfig({state:s, alt:0, context: ctx}, null);\n    if (lookBusy.contains(c)) {\n        return;\n    }\n    lookBusy.add(c);\n    if (s === stopState) {\n        if (ctx ===null) {\n            look.addOne(Token.EPSILON);\n            return;\n        } else if (ctx.isEmpty() && addEOF) {\n            look.addOne(Token.EOF);\n            return;\n        }\n    }\n    if (s instanceof RuleStopState ) {\n        if (ctx ===null) {\n            look.addOne(Token.EPSILON);\n            return;\n        } else if (ctx.isEmpty() && addEOF) {\n            look.addOne(Token.EOF);\n            return;\n        }\n        if (ctx !== PredictionContext.EMPTY) {\n            // run thru all possible stack tops in ctx\n            for(var i=0; i<ctx.length; i++) {\n                var returnState = this.atn.states[ctx.getReturnState(i)];\n                var removed = calledRuleStack.contains(returnState.ruleIndex);\n                try {\n                    calledRuleStack.remove(returnState.ruleIndex);\n                    this._LOOK(returnState, stopState, ctx.getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\n                } finally {\n                    if (removed) {\n                        calledRuleStack.add(returnState.ruleIndex);\n                    }\n                }\n            }\n            return;\n        }\n    }\n    for(var j=0; j<s.transitions.length; j++) {\n        var t = s.transitions[j];\n        if (t.constructor === RuleTransition) {\n            if (calledRuleStack.contains(t.target.ruleIndex)) {\n                continue;\n            }\n            var newContext = SingletonPredictionContext.create(ctx, t.followState.stateNumber);\n            try {\n                calledRuleStack.add(t.target.ruleIndex);\n                this._LOOK(t.target, stopState, newContext, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\n            } finally {\n                calledRuleStack.remove(t.target.ruleIndex);\n            }\n        } else if (t instanceof AbstractPredicateTransition ) {\n            if (seeThruPreds) {\n                this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\n            } else {\n                look.addOne(LL1Analyzer.HIT_PRED);\n            }\n        } else if( t.isEpsilon) {\n            this._LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);\n        } else if (t.constructor === WildcardTransition) {\n            look.addRange( Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType );\n        } else {\n            var set = t.label;\n            if (set !== null) {\n                if (t instanceof NotSetTransition) {\n                    set = set.complement(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);\n                }\n                look.addSet(set);\n            }\n        }\n    }\n};\n\nexports.LL1Analyzer = LL1Analyzer;\n\n\n},{\"./IntervalSet\":6,\"./PredictionContext\":11,\"./Token\":14,\"./Utils\":15,\"./atn/ATNConfig\":17,\"./atn/ATNState\":22,\"./atn/Transition\":30}],8:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  this SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  this SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n// A lexer is recognizer that draws input symbols from a character stream.\n//  lexer grammars result in a subclass of this object. A Lexer object\n//  uses simplified match() and error recovery mechanisms in the interest\n//  of speed.\n///\n\nvar Token = require('./Token').Token;\nvar Recognizer = require('./Recognizer').Recognizer;\nvar CommonTokenFactory = require('./CommonTokenFactory').CommonTokenFactory;\nvar LexerNoViableAltException = require('./error/Errors').LexerNoViableAltException;\n\nfunction TokenSource() {\n\treturn this;\n}\n\nfunction Lexer(input) {\n\tRecognizer.call(this);\n\tthis._input = input;\n\tthis._factory = CommonTokenFactory.DEFAULT;\n\tthis._tokenFactorySourcePair = [ this, input ];\n\n\tthis._interp = null; // child classes must populate this\n\n\t// The goal of all lexer rules/methods is to create a token object.\n\t// this is an instance variable as multiple rules may collaborate to\n\t// create a single token. nextToken will return this object after\n\t// matching lexer rule(s). If you subclass to allow multiple token\n\t// emissions, then set this to the last token to be matched or\n\t// something nonnull so that the auto token emit mechanism will not\n\t// emit another token.\n\tthis._token = null;\n\n\t// What character index in the stream did the current token start at?\n\t// Needed, for example, to get the text for current token. Set at\n\t// the start of nextToken.\n\tthis._tokenStartCharIndex = -1;\n\n\t// The line on which the first character of the token resides///\n\tthis._tokenStartLine = -1;\n\n\t// The character position of first character within the line///\n\tthis._tokenStartColumn = -1;\n\n\t// Once we see EOF on char stream, next token will be EOF.\n\t// If you have DONE : EOF ; then you see DONE EOF.\n\tthis._hitEOF = false;\n\n\t// The channel number for the current token///\n\tthis._channel = Token.DEFAULT_CHANNEL;\n\n\t// The token type for the current token///\n\tthis._type = Token.INVALID_TYPE;\n\n\tthis._modeStack = [];\n\tthis._mode = Lexer.DEFAULT_MODE;\n\n\t// You can set the text for the current token to override what is in\n\t// the input char buffer. Use setText() or can set this instance var.\n\t// /\n\tthis._text = null;\n\n\treturn this;\n}\n\nLexer.prototype = Object.create(Recognizer.prototype);\nLexer.prototype.constructor = Lexer;\n\nLexer.DEFAULT_MODE = 0;\nLexer.MORE = -2;\nLexer.SKIP = -3;\n\nLexer.DEFAULT_TOKEN_CHANNEL = Token.DEFAULT_CHANNEL;\nLexer.HIDDEN = Token.HIDDEN_CHANNEL;\nLexer.MIN_CHAR_VALUE = '\\u0000';\nLexer.MAX_CHAR_VALUE = '\\uFFFE';\n\nLexer.prototype.reset = function() {\n\t// wack Lexer state variables\n\tif (this._input !== null) {\n\t\tthis._input.seek(0); // rewind the input\n\t}\n\tthis._token = null;\n\tthis._type = Token.INVALID_TYPE;\n\tthis._channel = Token.DEFAULT_CHANNEL;\n\tthis._tokenStartCharIndex = -1;\n\tthis._tokenStartColumn = -1;\n\tthis._tokenStartLine = -1;\n\tthis._text = null;\n\n\tthis._hitEOF = false;\n\tthis._mode = Lexer.DEFAULT_MODE;\n\tthis._modeStack = [];\n\n\tthis._interp.reset();\n};\n\n// Return a token from this source; i.e., match a token on the char stream.\nLexer.prototype.nextToken = function() {\n\tif (this._input === null) {\n\t\tthrow \"nextToken requires a non-null input stream.\";\n\t}\n\n\t// Mark start location in char stream so unbuffered streams are\n\t// guaranteed at least have text of current token\n\tvar tokenStartMarker = this._input.mark();\n\ttry {\n\t\twhile (true) {\n\t\t\tif (this._hitEOF) {\n\t\t\t\tthis.emitEOF();\n\t\t\t\treturn this._token;\n\t\t\t}\n\t\t\tthis._token = null;\n\t\t\tthis._channel = Token.DEFAULT_CHANNEL;\n\t\t\tthis._tokenStartCharIndex = this._input.index;\n\t\t\tthis._tokenStartColumn = this._interp.column;\n\t\t\tthis._tokenStartLine = this._interp.line;\n\t\t\tthis._text = null;\n\t\t\tvar continueOuter = false;\n\t\t\twhile (true) {\n\t\t\t\tthis._type = Token.INVALID_TYPE;\n\t\t\t\tvar ttype = Lexer.SKIP;\n\t\t\t\ttry {\n\t\t\t\t\tttype = this._interp.match(this._input, this._mode);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tthis.notifyListeners(e); // report error\n\t\t\t\t\tthis.recover(e);\n\t\t\t\t}\n\t\t\t\tif (this._input.LA(1) === Token.EOF) {\n\t\t\t\t\tthis._hitEOF = true;\n\t\t\t\t}\n\t\t\t\tif (this._type === Token.INVALID_TYPE) {\n\t\t\t\t\tthis._type = ttype;\n\t\t\t\t}\n\t\t\t\tif (this._type === Lexer.SKIP) {\n\t\t\t\t\tcontinueOuter = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tif (this._type !== Lexer.MORE) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (continueOuter) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (this._token === null) {\n\t\t\t\tthis.emit();\n\t\t\t}\n\t\t\treturn this._token;\n\t\t}\n\t} finally {\n\t\t// make sure we release marker after match or\n\t\t// unbuffered char stream will keep buffering\n\t\tthis._input.release(tokenStartMarker);\n\t}\n};\n\n// Instruct the lexer to skip creating a token for current lexer rule\n// and look for another token. nextToken() knows to keep looking when\n// a lexer rule finishes with token set to SKIP_TOKEN. Recall that\n// if token==null at end of any token rule, it creates one for you\n// and emits it.\n// /\nLexer.prototype.skip = function() {\n\tthis._type = Lexer.SKIP;\n};\n\nLexer.prototype.more = function() {\n\tthis._type = Lexer.MORE;\n};\n\nLexer.prototype.mode = function(m) {\n\tthis._mode = m;\n};\n\nLexer.prototype.pushMode = function(m) {\n\tif (this._interp.debug) {\n\t\tconsole.log(\"pushMode \" + m);\n\t}\n\tthis._modeStack.push(this._mode);\n\tthis.mode(m);\n};\n\nLexer.prototype.popMode = function() {\n\tif (this._modeStack.length === 0) {\n\t\tthrow \"Empty Stack\";\n\t}\n\tif (this._interp.debug) {\n\t\tconsole.log(\"popMode back to \" + this._modeStack.slice(0, -1));\n\t}\n\tthis.mode(this._modeStack.pop());\n\treturn this._mode;\n};\n\n// Set the char stream and reset the lexer\nObject.defineProperty(Lexer.prototype, \"inputStream\", {\n\tget : function() {\n\t\treturn this._input;\n\t},\n\tset : function(input) {\n\t\tthis._input = null;\n\t\tthis._tokenFactorySourcePair = [ this, this._input ];\n\t\tthis.reset();\n\t\tthis._input = input;\n\t\tthis._tokenFactorySourcePair = [ this, this._input ];\n\t}\n});\n\nObject.defineProperty(Lexer.prototype, \"sourceName\", {\n\tget : function sourceName() {\n\t\treturn this._input.sourceName;\n\t}\n});\n\n// By default does not support multiple emits per nextToken invocation\n// for efficiency reasons. Subclass and override this method, nextToken,\n// and getToken (to push tokens into a list and pull from that list\n// rather than a single variable as this implementation does).\n// /\nLexer.prototype.emitToken = function(token) {\n\tthis._token = token;\n};\n\n// The standard method called to automatically emit a token at the\n// outermost lexical rule. The token object should point into the\n// char buffer start..stop. If there is a text override in 'text',\n// use that to set the token's text. Override this method to emit\n// custom Token objects or provide a new factory.\n// /\nLexer.prototype.emit = function() {\n\tvar t = this._factory.create(this._tokenFactorySourcePair, this._type,\n\t\t\tthis._text, this._channel, this._tokenStartCharIndex, this\n\t\t\t\t\t.getCharIndex() - 1, this._tokenStartLine,\n\t\t\tthis._tokenStartColumn);\n\tthis.emitToken(t);\n\treturn t;\n};\n\nLexer.prototype.emitEOF = function() {\n\tvar cpos = this.column;\n\tvar lpos = this.line;\n\tvar eof = this._factory.create(this._tokenFactorySourcePair, Token.EOF,\n\t\t\tnull, Token.DEFAULT_CHANNEL, this._input.index,\n\t\t\tthis._input.index - 1, lpos, cpos);\n\tthis.emitToken(eof);\n\treturn eof;\n};\n\nObject.defineProperty(Lexer.prototype, \"type\", {\n\tget : function() {\n\t\treturn this.type;\n\t},\n\tset : function(type) {\n\t\tthis._type = type;\n\t}\n});\n\nObject.defineProperty(Lexer.prototype, \"line\", {\n\tget : function() {\n\t\treturn this._interp.line;\n\t},\n\tset : function(line) {\n\t\tthis._interp.line = line;\n\t}\n});\n\nObject.defineProperty(Lexer.prototype, \"column\", {\n\tget : function() {\n\t\treturn this._interp.column;\n\t},\n\tset : function(column) {\n\t\tthis._interp.column = column;\n\t}\n});\n\n\n// What is the index of the current character of lookahead?///\nLexer.prototype.getCharIndex = function() {\n\treturn this._input.index;\n};\n\n// Return the text matched so far for the current token or any text override.\n//Set the complete text of this token; it wipes any previous changes to the text.\nObject.defineProperty(Lexer.prototype, \"text\", {\n\tget : function() {\n\t\tif (this._text !== null) {\n\t\t\treturn this._text;\n\t\t} else {\n\t\t\treturn this._interp.getText(this._input);\n\t\t}\n\t},\n\tset : function(text) {\n\t\tthis._text = text;\n\t}\n});\n// Return a list of all Token objects in input char stream.\n// Forces load of all tokens. Does not include EOF token.\n// /\nLexer.prototype.getAllTokens = function() {\n\tvar tokens = [];\n\tvar t = this.nextToken();\n\twhile (t.type !== Token.EOF) {\n\t\ttokens.push(t);\n\t\tt = this.nextToken();\n\t}\n\treturn tokens;\n};\n\nLexer.prototype.notifyListeners = function(e) {\n\tvar start = this._tokenStartCharIndex;\n\tvar stop = this._input.index;\n\tvar text = this._input.getText(start, stop);\n\tvar msg = \"token recognition error at: '\" + this.getErrorDisplay(text) + \"'\";\n\tvar listener = this.getErrorListenerDispatch();\n\tlistener.syntaxError(this, null, this._tokenStartLine,\n\t\t\tthis._tokenStartColumn, msg, e);\n};\n\nLexer.prototype.getErrorDisplay = function(s) {\n\tvar d = [];\n\tfor (var i = 0; i < s.length; i++) {\n\t\td.push(s[i]);\n\t}\n\treturn d.join('');\n};\n\nLexer.prototype.getErrorDisplayForChar = function(c) {\n\tif (c.charCodeAt(0) === Token.EOF) {\n\t\treturn \"<EOF>\";\n\t} else if (c === '\\n') {\n\t\treturn \"\\\\n\";\n\t} else if (c === '\\t') {\n\t\treturn \"\\\\t\";\n\t} else if (c === '\\r') {\n\t\treturn \"\\\\r\";\n\t} else {\n\t\treturn c;\n\t}\n};\n\nLexer.prototype.getCharErrorDisplay = function(c) {\n\treturn \"'\" + this.getErrorDisplayForChar(c) + \"'\";\n};\n\n// Lexers can normally match any char in it's vocabulary after matching\n// a token, so do the easy thing and just kill a character and hope\n// it all works out. You can instead use the rule invocation stack\n// to do sophisticated error recovery if you are in a fragment rule.\n// /\nLexer.prototype.recover = function(re) {\n\tif (this._input.LA(1) !== Token.EOF) {\n\t\tif (re instanceof LexerNoViableAltException) {\n\t\t\t// skip a char and try again\n\t\t\tthis._interp.consume(this._input);\n\t\t} else {\n\t\t\t// TODO: Do we lose character or line position information?\n\t\t\tthis._input.consume();\n\t\t}\n\t}\n};\n\nexports.Lexer = Lexer;\n\n},{\"./CommonTokenFactory\":2,\"./Recognizer\":12,\"./Token\":14,\"./error/Errors\":39}],9:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  this SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  this SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nvar Token = require('./Token').Token;\nvar ParseTreeListener = require('./tree/Tree').ParseTreeListener;\nvar Recognizer = require('./Recognizer').Recognizer;\nvar DefaultErrorStrategy = require('./error/ErrorStrategy').DefaultErrorStrategy;\nvar ATNDeserializer = require('./atn/ATNDeserializer').ATNDeserializer;\nvar ATNDeserializationOptions = require('./atn/ATNDeserializationOptions').ATNDeserializationOptions;\n\nfunction TraceListener(parser) {\n\tParseTreeListener.call(this);\n    this.parser = parser;\n\treturn this;\n}\n\nTraceListener.prototype = Object.create(ParseTreeListener);\nTraceListener.prototype.constructor = TraceListener;\n\nTraceListener.prototype.enterEveryRule = function(ctx) {\n\tconsole.log(\"enter   \" + this.parser.ruleNames[ctx.ruleIndex] + \", LT(1)=\" + this.parser._input.LT(1).text);\n};\n\nTraceListener.prototype.visitTerminal = function( node) {\n\tconsole.log(\"consume \" + node.symbol + \" rule \" + this.parser.ruleNames[this.parser._ctx.ruleIndex]);\n};\n\nTraceListener.prototype.exitEveryRule = function(ctx) {\n\tconsole.log(\"exit    \" + this.parser.ruleNames[ctx.ruleIndex] + \", LT(1)=\" + this.parser._input.LT(1).text);\n};\n\n// this is all the parsing support code essentially; most of it is error\n// recovery stuff.//\nfunction Parser(input) {\n\tRecognizer.call(this);\n\t// The input stream.\n\tthis._input = null;\n\t// The error handling strategy for the parser. The default value is a new\n\t// instance of {@link DefaultErrorStrategy}.\n\tthis._errHandler = new DefaultErrorStrategy();\n\tthis._precedenceStack = [];\n\tthis._precedenceStack.push(0);\n\t// The {@link ParserRuleContext} object for the currently executing rule.\n\t// this is always non-null during the parsing process.\n\tthis._ctx = null;\n\t// Specifies whether or not the parser should construct a parse tree during\n\t// the parsing process. The default value is {@code true}.\n\tthis.buildParseTrees = true;\n\t// When {@link //setTrace}{@code (true)} is called, a reference to the\n\t// {@link TraceListener} is stored here so it can be easily removed in a\n\t// later call to {@link //setTrace}{@code (false)}. The listener itself is\n\t// implemented as a parser listener so this field is not directly used by\n\t// other parser methods.\n\tthis._tracer = null;\n\t// The list of {@link ParseTreeListener} listeners registered to receive\n\t// events during the parse.\n\tthis._parseListeners = null;\n\t// The number of syntax errors reported during parsing. this value is\n\t// incremented each time {@link //notifyErrorListeners} is called.\n\tthis._syntaxErrors = 0;\n\tthis.setInputStream(input);\n\treturn this;\n}\n\nParser.prototype = Object.create(Recognizer.prototype);\nParser.prototype.contructor = Parser;\n\n// this field maps from the serialized ATN string to the deserialized {@link\n// ATN} with\n// bypass alternatives.\n//\n// @see ATNDeserializationOptions//isGenerateRuleBypassTransitions()\n//\nParser.bypassAltsAtnCache = {};\n\n// reset the parser's state//\nParser.prototype.reset = function() {\n\tif (this._input !== null) {\n\t\tthis._input.seek(0);\n\t}\n\tthis._errHandler.reset(this);\n\tthis._ctx = null;\n\tthis._syntaxErrors = 0;\n\tthis.setTrace(false);\n\tthis._precedenceStack = [];\n\tthis._precedenceStack.push(0);\n\tif (this._interp !== null) {\n\t\tthis._interp.reset();\n\t}\n};\n\n// Match current input symbol against {@code ttype}. If the symbol type\n// matches, {@link ANTLRErrorStrategy//reportMatch} and {@link //consume} are\n// called to complete the match process.\n//\n// <p>If the symbol type does not match,\n// {@link ANTLRErrorStrategy//recoverInline} is called on the current error\n// strategy to attempt recovery. If {@link //getBuildParseTree} is\n// {@code true} and the token index of the symbol returned by\n// {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to\n// the parse tree by calling {@link ParserRuleContext//addErrorNode}.</p>\n//\n// @param ttype the token type to match\n// @return the matched symbol\n// @throws RecognitionException if the current input symbol did not match\n// {@code ttype} and the error strategy could not recover from the\n// mismatched symbol\n\nParser.prototype.match = function(ttype) {\n\tvar t = this.getCurrentToken();\n\tif (t.type === ttype) {\n\t\tthis._errHandler.reportMatch(this);\n\t\tthis.consume();\n\t} else {\n\t\tt = this._errHandler.recoverInline(this);\n\t\tif (this.buildParseTrees && t.tokenIndex === -1) {\n\t\t\t// we must have conjured up a new token during single token\n\t\t\t// insertion\n\t\t\t// if it's not the current symbol\n\t\t\tthis._ctx.addErrorNode(t);\n\t\t}\n\t}\n\treturn t;\n};\n// Match current input symbol as a wildcard. If the symbol type matches\n// (i.e. has a value greater than 0), {@link ANTLRErrorStrategy//reportMatch}\n// and {@link //consume} are called to complete the match process.\n//\n// <p>If the symbol type does not match,\n// {@link ANTLRErrorStrategy//recoverInline} is called on the current error\n// strategy to attempt recovery. If {@link //getBuildParseTree} is\n// {@code true} and the token index of the symbol returned by\n// {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to\n// the parse tree by calling {@link ParserRuleContext//addErrorNode}.</p>\n//\n// @return the matched symbol\n// @throws RecognitionException if the current input symbol did not match\n// a wildcard and the error strategy could not recover from the mismatched\n// symbol\n\nParser.prototype.matchWildcard = function() {\n\tvar t = this.getCurrentToken();\n\tif (t.type > 0) {\n\t\tthis._errHandler.reportMatch(this);\n\t\tthis.consume();\n\t} else {\n\t\tt = this._errHandler.recoverInline(this);\n\t\tif (this._buildParseTrees && t.tokenIndex === -1) {\n\t\t\t// we must have conjured up a new token during single token\n\t\t\t// insertion\n\t\t\t// if it's not the current symbol\n\t\t\tthis._ctx.addErrorNode(t);\n\t\t}\n\t}\n\treturn t;\n};\n\nParser.prototype.getParseListeners = function() {\n\treturn this._parseListeners || [];\n};\n\n// Registers {@code listener} to receive events during the parsing process.\n//\n// <p>To support output-preserving grammar transformations (including but not\n// limited to left-recursion removal, automated left-factoring, and\n// optimized code generation), calls to listener methods during the parse\n// may differ substantially from calls made by\n// {@link ParseTreeWalker//DEFAULT} used after the parse is complete. In\n// particular, rule entry and exit events may occur in a different order\n// during the parse than after the parser. In addition, calls to certain\n// rule entry methods may be omitted.</p>\n//\n// <p>With the following specific exceptions, calls to listener events are\n// <em>deterministic</em>, i.e. for identical input the calls to listener\n// methods will be the same.</p>\n//\n// <ul>\n// <li>Alterations to the grammar used to generate code may change the\n// behavior of the listener calls.</li>\n// <li>Alterations to the command line options passed to ANTLR 4 when\n// generating the parser may change the behavior of the listener calls.</li>\n// <li>Changing the version of the ANTLR Tool used to generate the parser\n// may change the behavior of the listener calls.</li>\n// </ul>\n//\n// @param listener the listener to add\n//\n// @throws NullPointerException if {@code} listener is {@code null}\n//\nParser.prototype.addParseListener = function(listener) {\n\tif (listener === null) {\n\t\tthrow \"listener\";\n\t}\n\tif (this._parseListeners === null) {\n\t\tthis._parseListeners = [];\n\t}\n\tthis._parseListeners.push(listener);\n};\n\n//\n// Remove {@code listener} from the list of parse listeners.\n//\n// <p>If {@code listener} is {@code null} or has not been added as a parse\n// listener, this method does nothing.</p>\n// @param listener the listener to remove\n//\nParser.prototype.removeParseListener = function(listener) {\n\tif (this._parseListeners !== null) {\n\t\tvar idx = this._parseListeners.indexOf(listener);\n\t\tif (idx >= 0) {\n\t\t\tthis._parseListeners.splice(idx, 1);\n\t\t}\n\t\tif (this._parseListeners.length === 0) {\n\t\t\tthis._parseListeners = null;\n\t\t}\n\t}\n};\n\n// Remove all parse listeners.\nParser.prototype.removeParseListeners = function() {\n\tthis._parseListeners = null;\n};\n\n// Notify any parse listeners of an enter rule event.\nParser.prototype.triggerEnterRuleEvent = function() {\n\tif (this._parseListeners !== null) {\n        var ctx = this._ctx;\n\t\tthis._parseListeners.map(function(listener) {\n\t\t\tlistener.enterEveryRule(ctx);\n\t\t\tctx.enterRule(listener);\n\t\t});\n\t}\n};\n\n//\n// Notify any parse listeners of an exit rule event.\n//\n// @see //addParseListener\n//\nParser.prototype.triggerExitRuleEvent = function() {\n\tif (this._parseListeners !== null) {\n\t\t// reverse order walk of listeners\n        var ctx = this._ctx;\n\t\tthis._parseListeners.slice(0).reverse().map(function(listener) {\n\t\t\tctx.exitRule(listener);\n\t\t\tlistener.exitEveryRule(ctx);\n\t\t});\n\t}\n};\n\nParser.prototype.getTokenFactory = function() {\n\treturn this._input.tokenSource._factory;\n};\n\n// Tell our token source and error strategy about a new way to create tokens.//\nParser.prototype.setTokenFactory = function(factory) {\n\tthis._input.tokenSource._factory = factory;\n};\n\n// The ATN with bypass alternatives is expensive to create so we create it\n// lazily.\n//\n// @throws UnsupportedOperationException if the current parser does not\n// implement the {@link //getSerializedATN()} method.\n//\nParser.prototype.getATNWithBypassAlts = function() {\n\tvar serializedAtn = this.getSerializedATN();\n\tif (serializedAtn === null) {\n\t\tthrow \"The current parser does not support an ATN with bypass alternatives.\";\n\t}\n\tvar result = this.bypassAltsAtnCache[serializedAtn];\n\tif (result === null) {\n\t\tvar deserializationOptions = new ATNDeserializationOptions();\n\t\tdeserializationOptions.generateRuleBypassTransitions = true;\n\t\tresult = new ATNDeserializer(deserializationOptions)\n\t\t\t\t.deserialize(serializedAtn);\n\t\tthis.bypassAltsAtnCache[serializedAtn] = result;\n\t}\n\treturn result;\n};\n\n// The preferred method of getting a tree pattern. For example, here's a\n// sample use:\n//\n// <pre>\n// ParseTree t = parser.expr();\n// ParseTreePattern p = parser.compileParseTreePattern(\"&lt;ID&gt;+0\",\n// MyParser.RULE_expr);\n// ParseTreeMatch m = p.match(t);\n// String id = m.get(\"ID\");\n// </pre>\n\nvar Lexer = require('./Lexer').Lexer;\n\nParser.prototype.compileParseTreePattern = function(pattern, patternRuleIndex, lexer) {\n\tlexer = lexer || null;\n\tif (lexer === null) {\n\t\tif (this.getTokenStream() !== null) {\n\t\t\tvar tokenSource = this.getTokenStream().tokenSource;\n\t\t\tif (tokenSource instanceof Lexer) {\n\t\t\t\tlexer = tokenSource;\n\t\t\t}\n\t\t}\n\t}\n\tif (lexer === null) {\n\t\tthrow \"Parser can't discover a lexer to use\";\n\t}\n\tvar m = new ParseTreePatternMatcher(lexer, this);\n\treturn m.compile(pattern, patternRuleIndex);\n};\n\nParser.prototype.getInputStream = function() {\n\treturn this.getTokenStream();\n};\n\nParser.prototype.setInputStream = function(input) {\n\tthis.setTokenStream(input);\n};\n\nParser.prototype.getTokenStream = function() {\n\treturn this._input;\n};\n\n// Set the token stream and reset the parser.//\nParser.prototype.setTokenStream = function(input) {\n\tthis._input = null;\n\tthis.reset();\n\tthis._input = input;\n};\n\n// Match needs to return the current input symbol, which gets put\n// into the label for the associated token ref; e.g., x=ID.\n//\nParser.prototype.getCurrentToken = function() {\n\treturn this._input.LT(1);\n};\n\nParser.prototype.notifyErrorListeners = function(msg, offendingToken, err) {\n\toffendingToken = offendingToken || null;\n\terr = err || null;\n\tif (offendingToken === null) {\n\t\toffendingToken = this.getCurrentToken();\n\t}\n\tthis._syntaxErrors += 1;\n\tvar line = offendingToken.line;\n\tvar column = offendingToken.column;\n\tvar listener = this.getErrorListenerDispatch();\n\tlistener.syntaxError(this, offendingToken, line, column, msg, err);\n};\n\n//\n// Consume and return the {@linkplain //getCurrentToken current symbol}.\n//\n// <p>E.g., given the following input with {@code A} being the current\n// lookahead symbol, this function moves the cursor to {@code B} and returns\n// {@code A}.</p>\n//\n// <pre>\n// A B\n// ^\n// </pre>\n//\n// If the parser is not in error recovery mode, the consumed symbol is added\n// to the parse tree using {@link ParserRuleContext//addChild(Token)}, and\n// {@link ParseTreeListener//visitTerminal} is called on any parse listeners.\n// If the parser <em>is</em> in error recovery mode, the consumed symbol is\n// added to the parse tree using\n// {@link ParserRuleContext//addErrorNode(Token)}, and\n// {@link ParseTreeListener//visitErrorNode} is called on any parse\n// listeners.\n//\nParser.prototype.consume = function() {\n\tvar o = this.getCurrentToken();\n\tif (o.type !== Token.EOF) {\n\t\tthis.getInputStream().consume();\n\t}\n\tvar hasListener = this._parseListeners !== null && this._parseListeners.length > 0;\n\tif (this.buildParseTrees || hasListener) {\n\t\tvar node;\n\t\tif (this._errHandler.inErrorRecoveryMode(this)) {\n\t\t\tnode = this._ctx.addErrorNode(o);\n\t\t} else {\n\t\t\tnode = this._ctx.addTokenNode(o);\n\t\t}\n        node.invokingState = this.state;\n\t\tif (hasListener) {\n\t\t\tthis._parseListeners.map(function(listener) {\n\t\t\t\tlistener.visitTerminal(node);\n\t\t\t});\n\t\t}\n\t}\n\treturn o;\n};\n\nParser.prototype.addContextToParseTree = function() {\n\t// add current context to parent if we have a parent\n\tif (this._ctx.parentCtx !== null) {\n\t\tthis._ctx.parentCtx.addChild(this._ctx);\n\t}\n};\n\n// Always called by generated parsers upon entry to a rule. Access field\n// {@link //_ctx} get the current context.\n\nParser.prototype.enterRule = function(localctx, state, ruleIndex) {\n\tthis.state = state;\n\tthis._ctx = localctx;\n\tthis._ctx.start = this._input.LT(1);\n\tif (this.buildParseTrees) {\n\t\tthis.addContextToParseTree();\n\t}\n\tif (this._parseListeners !== null) {\n\t\tthis.triggerEnterRuleEvent();\n\t}\n};\n\nParser.prototype.exitRule = function() {\n\tthis._ctx.stop = this._input.LT(-1);\n\t// trigger event on _ctx, before it reverts to parent\n\tif (this._parseListeners !== null) {\n\t\tthis.triggerExitRuleEvent();\n\t}\n\tthis.state = this._ctx.invokingState;\n\tthis._ctx = this._ctx.parentCtx;\n};\n\nParser.prototype.enterOuterAlt = function(localctx, altNum) {\n   \tlocalctx.setAltNumber(altNum);\n\t// if we have new localctx, make sure we replace existing ctx\n\t// that is previous child of parse tree\n\tif (this.buildParseTrees && this._ctx !== localctx) {\n\t\tif (this._ctx.parentCtx !== null) {\n\t\t\tthis._ctx.parentCtx.removeLastChild();\n\t\t\tthis._ctx.parentCtx.addChild(localctx);\n\t\t}\n\t}\n\tthis._ctx = localctx;\n};\n\n// Get the precedence level for the top-most precedence rule.\n//\n// @return The precedence level for the top-most precedence rule, or -1 if\n// the parser context is not nested within a precedence rule.\n\nParser.prototype.getPrecedence = function() {\n\tif (this._precedenceStack.length === 0) {\n\t\treturn -1;\n\t} else {\n\t\treturn this._precedenceStack[this._precedenceStack.length-1];\n\t}\n};\n\nParser.prototype.enterRecursionRule = function(localctx, state, ruleIndex,\n\t\tprecedence) {\n\tthis.state = state;\n\tthis._precedenceStack.push(precedence);\n\tthis._ctx = localctx;\n\tthis._ctx.start = this._input.LT(1);\n\tif (this._parseListeners !== null) {\n\t\tthis.triggerEnterRuleEvent(); // simulates rule entry for\n\t\t\t\t\t\t\t\t\t\t// left-recursive rules\n\t}\n};\n\n//\n// Like {@link //enterRule} but for recursive rules.\n\nParser.prototype.pushNewRecursionContext = function(localctx, state, ruleIndex) {\n\tvar previous = this._ctx;\n\tprevious.parentCtx = localctx;\n\tprevious.invokingState = state;\n\tprevious.stop = this._input.LT(-1);\n\n\tthis._ctx = localctx;\n\tthis._ctx.start = previous.start;\n\tif (this.buildParseTrees) {\n\t\tthis._ctx.addChild(previous);\n\t}\n\tif (this._parseListeners !== null) {\n\t\tthis.triggerEnterRuleEvent(); // simulates rule entry for\n\t\t\t\t\t\t\t\t\t\t// left-recursive rules\n\t}\n};\n\nParser.prototype.unrollRecursionContexts = function(parentCtx) {\n\tthis._precedenceStack.pop();\n\tthis._ctx.stop = this._input.LT(-1);\n\tvar retCtx = this._ctx; // save current ctx (return value)\n\t// unroll so _ctx is as it was before call to recursive method\n\tif (this._parseListeners !== null) {\n\t\twhile (this._ctx !== parentCtx) {\n\t\t\tthis.triggerExitRuleEvent();\n\t\t\tthis._ctx = this._ctx.parentCtx;\n\t\t}\n\t} else {\n\t\tthis._ctx = parentCtx;\n\t}\n\t// hook into tree\n\tretCtx.parentCtx = parentCtx;\n\tif (this.buildParseTrees && parentCtx !== null) {\n\t\t// add return ctx into invoking rule's tree\n\t\tparentCtx.addChild(retCtx);\n\t}\n};\n\nParser.prototype.getInvokingContext = function(ruleIndex) {\n\tvar ctx = this._ctx;\n\twhile (ctx !== null) {\n\t\tif (ctx.ruleIndex === ruleIndex) {\n\t\t\treturn ctx;\n\t\t}\n\t\tctx = ctx.parentCtx;\n\t}\n\treturn null;\n};\n\nParser.prototype.precpred = function(localctx, precedence) {\n\treturn precedence >= this._precedenceStack[this._precedenceStack.length-1];\n};\n\nParser.prototype.inContext = function(context) {\n\t// TODO: useful in parser?\n\treturn false;\n};\n\n//\n// Checks whether or not {@code symbol} can follow the current state in the\n// ATN. The behavior of this method is equivalent to the following, but is\n// implemented such that the complete context-sensitive follow set does not\n// need to be explicitly constructed.\n//\n// <pre>\n// return getExpectedTokens().contains(symbol);\n// </pre>\n//\n// @param symbol the symbol type to check\n// @return {@code true} if {@code symbol} can follow the current state in\n// the ATN, otherwise {@code false}.\n\nParser.prototype.isExpectedToken = function(symbol) {\n\tvar atn = this._interp.atn;\n\tvar ctx = this._ctx;\n\tvar s = atn.states[this.state];\n\tvar following = atn.nextTokens(s);\n\tif (following.contains(symbol)) {\n\t\treturn true;\n\t}\n\tif (!following.contains(Token.EPSILON)) {\n\t\treturn false;\n\t}\n\twhile (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {\n\t\tvar invokingState = atn.states[ctx.invokingState];\n\t\tvar rt = invokingState.transitions[0];\n\t\tfollowing = atn.nextTokens(rt.followState);\n\t\tif (following.contains(symbol)) {\n\t\t\treturn true;\n\t\t}\n\t\tctx = ctx.parentCtx;\n\t}\n\tif (following.contains(Token.EPSILON) && symbol === Token.EOF) {\n\t\treturn true;\n\t} else {\n\t\treturn false;\n\t}\n};\n\n// Computes the set of input symbols which could follow the current parser\n// state and context, as given by {@link //getState} and {@link //getContext},\n// respectively.\n//\n// @see ATN//getExpectedTokens(int, RuleContext)\n//\nParser.prototype.getExpectedTokens = function() {\n\treturn this._interp.atn.getExpectedTokens(this.state, this._ctx);\n};\n\nParser.prototype.getExpectedTokensWithinCurrentRule = function() {\n\tvar atn = this._interp.atn;\n\tvar s = atn.states[this.state];\n\treturn atn.nextTokens(s);\n};\n\n// Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.//\nParser.prototype.getRuleIndex = function(ruleName) {\n\tvar ruleIndex = this.getRuleIndexMap()[ruleName];\n\tif (ruleIndex !== null) {\n\t\treturn ruleIndex;\n\t} else {\n\t\treturn -1;\n\t}\n};\n\n// Return List&lt;String&gt; of the rule names in your parser instance\n// leading up to a call to the current rule. You could override if\n// you want more details such as the file/line info of where\n// in the ATN a rule is invoked.\n//\n// this is very useful for error messages.\n//\nParser.prototype.getRuleInvocationStack = function(p) {\n\tp = p || null;\n\tif (p === null) {\n\t\tp = this._ctx;\n\t}\n\tvar stack = [];\n\twhile (p !== null) {\n\t\t// compute what follows who invoked us\n\t\tvar ruleIndex = p.ruleIndex;\n\t\tif (ruleIndex < 0) {\n\t\t\tstack.push(\"n/a\");\n\t\t} else {\n\t\t\tstack.push(this.ruleNames[ruleIndex]);\n\t\t}\n\t\tp = p.parentCtx;\n\t}\n\treturn stack;\n};\n\n// For debugging and other purposes.//\nParser.prototype.getDFAStrings = function() {\n\treturn this._interp.decisionToDFA.toString();\n};\n// For debugging and other purposes.//\nParser.prototype.dumpDFA = function() {\n\tvar seenOne = false;\n\tfor (var i = 0; i < this._interp.decisionToDFA.length; i++) {\n\t\tvar dfa = this._interp.decisionToDFA[i];\n\t\tif (dfa.states.length > 0) {\n\t\t\tif (seenOne) {\n\t\t\t\tconsole.log();\n\t\t\t}\n\t\t\tthis.printer.println(\"Decision \" + dfa.decision + \":\");\n\t\t\tthis.printer.print(dfa.toString(this.literalNames, this.symbolicNames));\n\t\t\tseenOne = true;\n\t\t}\n\t}\n};\n\n/*\n\"\t\t\tprinter = function() {\\r\\n\" +\n\"\t\t\t\tthis.println = function(s) { document.getElementById('output') += s + '\\\\n'; }\\r\\n\" +\n\"\t\t\t\tthis.print = function(s) { document.getElementById('output') += s; }\\r\\n\" +\n\"\t\t\t};\\r\\n\" +\n*/\n\nParser.prototype.getSourceName = function() {\n\treturn this._input.sourceName;\n};\n\n// During a parse is sometimes useful to listen in on the rule entry and exit\n// events as well as token matches. this is for quick and dirty debugging.\n//\nParser.prototype.setTrace = function(trace) {\n\tif (!trace) {\n\t\tthis.removeParseListener(this._tracer);\n\t\tthis._tracer = null;\n\t} else {\n\t\tif (this._tracer !== null) {\n\t\t\tthis.removeParseListener(this._tracer);\n\t\t}\n\t\tthis._tracer = new TraceListener(this);\n\t\tthis.addParseListener(this._tracer);\n\t}\n};\n\nexports.Parser = Parser;\n},{\"./Lexer\":8,\"./Recognizer\":12,\"./Token\":14,\"./atn/ATNDeserializationOptions\":19,\"./atn/ATNDeserializer\":20,\"./error/ErrorStrategy\":38,\"./tree/Tree\":42}],10:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n//* A rule invocation record for parsing.\n//\n//  Contains all of the information about the current rule not stored in the\n//  RuleContext. It handles parse tree children list, Any ATN state\n//  tracing, and the default values available for rule indications:\n//  start, stop, rule index, current alt number, current\n//  ATN state.\n//\n//  Subclasses made for each rule and grammar track the parameters,\n//  return values, locals, and labels specific to that rule. These\n//  are the objects that are returned from rules.\n//\n//  Note text is not an actual field of a rule return value; it is computed\n//  from start and stop using the input stream's toString() method.  I\n//  could add a ctor to this so that we can pass in and store the input\n//  stream, but I'm not sure we want to do that.  It would seem to be undefined\n//  to get the .text property anyway if the rule matches tokens from multiple\n//  input streams.\n//\n//  I do not use getters for fields of objects that are used simply to\n//  group values such as this aggregate.  The getters/setters are there to\n//  satisfy the superclass interface.\n\nvar RuleContext = require('./RuleContext').RuleContext;\nvar Tree = require('./tree/Tree');\nvar INVALID_INTERVAL = Tree.INVALID_INTERVAL;\nvar TerminalNode = Tree.TerminalNode;\nvar TerminalNodeImpl = Tree.TerminalNodeImpl;\nvar ErrorNodeImpl = Tree.ErrorNodeImpl;\nvar Interval = require(\"./IntervalSet\").Interval;\n\nfunction ParserRuleContext(parent, invokingStateNumber) {\n\tparent = parent || null;\n\tinvokingStateNumber = invokingStateNumber || null;\n\tRuleContext.call(this, parent, invokingStateNumber);\n\tthis.ruleIndex = -1;\n    // * If we are debugging or building a parse tree for a visitor,\n    // we need to track all of the tokens and rule invocations associated\n    // with this rule's context. This is empty for parsing w/o tree constr.\n    // operation because we don't the need to track the details about\n    // how we parse this rule.\n    // /\n    this.children = null;\n    this.start = null;\n    this.stop = null;\n    // The exception that forced this rule to return. If the rule successfully\n    // completed, this is {@code null}.\n    this.exception = null;\n}\n\nParserRuleContext.prototype = Object.create(RuleContext.prototype);\nParserRuleContext.prototype.constructor = ParserRuleContext;\n\n// * COPY a ctx (I'm deliberately not using copy constructor)///\nParserRuleContext.prototype.copyFrom = function(ctx) {\n    // from RuleContext\n    this.parentCtx = ctx.parentCtx;\n    this.invokingState = ctx.invokingState;\n    this.children = null;\n    this.start = ctx.start;\n    this.stop = ctx.stop;\n};\n\n// Double dispatch methods for listeners\nParserRuleContext.prototype.enterRule = function(listener) {\n};\n\nParserRuleContext.prototype.exitRule = function(listener) {\n};\n\n// * Does not set parent link; other add methods do that///\nParserRuleContext.prototype.addChild = function(child) {\n    if (this.children === null) {\n        this.children = [];\n    }\n    this.children.push(child);\n    return child;\n};\n\n// * Used by enterOuterAlt to toss out a RuleContext previously added as\n// we entered a rule. If we have // label, we will need to remove\n// generic ruleContext object.\n// /\nParserRuleContext.prototype.removeLastChild = function() {\n    if (this.children !== null) {\n        this.children.pop();\n    }\n};\n\nParserRuleContext.prototype.addTokenNode = function(token) {\n    var node = new TerminalNodeImpl(token);\n    this.addChild(node);\n    node.parentCtx = this;\n    return node;\n};\n\nParserRuleContext.prototype.addErrorNode = function(badToken) {\n    var node = new ErrorNodeImpl(badToken);\n    this.addChild(node);\n    node.parentCtx = this;\n    return node;\n};\n\nParserRuleContext.prototype.getChild = function(i, type) {\n\ttype = type || null;\n\tif (type === null) {\n\t\treturn this.children.length>=i ? this.children[i] : null;\n\t} else {\n\t\tfor(var j=0; j<this.children.length; j++) {\n\t\t\tvar child = this.children[j];\n\t\t\tif(child instanceof type) {\n\t\t\t\tif(i===0) {\n\t\t\t\t\treturn child;\n\t\t\t\t} else {\n\t\t\t\t\ti -= 1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn null;\n    }\n};\n\n\nParserRuleContext.prototype.getToken = function(ttype, i) {\n\tfor(var j=0; j<this.children.length; j++) {\n\t\tvar child = this.children[j];\n\t\tif (child instanceof TerminalNode) {\n\t\t\tif (child.symbol.type === ttype) {\n\t\t\t\tif(i===0) {\n\t\t\t\t\treturn child;\n\t\t\t\t} else {\n\t\t\t\t\ti -= 1;\n\t\t\t\t}\n\t\t\t}\n        }\n\t}\n    return null;\n};\n\nParserRuleContext.prototype.getTokens = function(ttype ) {\n    if (this.children=== null) {\n        return [];\n    } else {\n\t\tvar tokens = [];\n\t\tfor(var j=0; j<this.children.length; j++) {\n\t\t\tvar child = this.children[j];\n\t\t\tif (child instanceof TerminalNode) {\n\t\t\t\tif (child.symbol.type === ttype) {\n\t\t\t\t\ttokens.push(child);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn tokens;\n    }\n};\n\nParserRuleContext.prototype.getTypedRuleContext = function(ctxType, i) {\n    return this.getChild(i, ctxType);\n};\n\nParserRuleContext.prototype.getTypedRuleContexts = function(ctxType) {\n    if (this.children=== null) {\n        return [];\n    } else {\n\t\tvar contexts = [];\n\t\tfor(var j=0; j<this.children.length; j++) {\n\t\t\tvar child = this.children[j];\n\t\t\tif (child instanceof ctxType) {\n\t\t\t\tcontexts.push(child);\n\t\t\t}\n\t\t}\n\t\treturn contexts;\n\t}\n};\n\nParserRuleContext.prototype.getChildCount = function() {\n\tif (this.children=== null) {\n\t\treturn 0;\n\t} else {\n\t\treturn this.children.length;\n\t}\n};\n\nParserRuleContext.prototype.getSourceInterval = function() {\n    if( this.start === null || this.stop === null) {\n        return INVALID_INTERVAL;\n    } else {\n        return new Interval(this.start.tokenIndex, this.stop.tokenIndex);\n    }\n};\n\nRuleContext.EMPTY = new ParserRuleContext();\n\nfunction InterpreterRuleContext(parent, invokingStateNumber, ruleIndex) {\n\tParserRuleContext.call(parent, invokingStateNumber);\n    this.ruleIndex = ruleIndex;\n    return this;\n}\n\nInterpreterRuleContext.prototype = Object.create(ParserRuleContext.prototype);\nInterpreterRuleContext.prototype.constructor = InterpreterRuleContext;\n\nexports.ParserRuleContext = ParserRuleContext;\n},{\"./IntervalSet\":6,\"./RuleContext\":13,\"./tree/Tree\":42}],11:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\nvar RuleContext = require('./RuleContext').RuleContext;\n\nfunction PredictionContext(cachedHashString) {\n\tthis.cachedHashString = cachedHashString;\n}\n\n// Represents {@code $} in local context prediction, which means wildcard.\n// {@code//+x =//}.\n// /\nPredictionContext.EMPTY = null;\n\n// Represents {@code $} in an array in full context mode, when {@code $}\n// doesn't mean wildcard: {@code $ + x = [$,x]}. Here,\n// {@code $} = {@link //EMPTY_RETURN_STATE}.\n// /\nPredictionContext.EMPTY_RETURN_STATE = 0x7FFFFFFF;\n\nPredictionContext.globalNodeCount = 1;\nPredictionContext.id = PredictionContext.globalNodeCount;\n\n// Stores the computed hash code of this {@link PredictionContext}. The hash\n// code is computed in parts to match the following reference algorithm.\n//\n// <pre>\n// private int referenceHashCode() {\n// int hash = {@link MurmurHash//initialize MurmurHash.initialize}({@link\n// //INITIAL_HASH});\n//\n// for (int i = 0; i &lt; {@link //size()}; i++) {\n// hash = {@link MurmurHash//update MurmurHash.update}(hash, {@link //getParent\n// getParent}(i));\n// }\n//\n// for (int i = 0; i &lt; {@link //size()}; i++) {\n// hash = {@link MurmurHash//update MurmurHash.update}(hash, {@link\n// //getReturnState getReturnState}(i));\n// }\n//\n// hash = {@link MurmurHash//finish MurmurHash.finish}(hash, 2// {@link\n// //size()});\n// return hash;\n// }\n// </pre>\n// /\n\n// This means only the {@link //EMPTY} context is in set.\nPredictionContext.prototype.isEmpty = function() {\n\treturn this === PredictionContext.EMPTY;\n};\n\nPredictionContext.prototype.hasEmptyPath = function() {\n\treturn this.getReturnState(this.length - 1) === PredictionContext.EMPTY_RETURN_STATE;\n};\n\nPredictionContext.prototype.hashString = function() {\n\treturn this.cachedHashString;\n};\n\nfunction calculateHashString(parent, returnState) {\n\treturn \"\" + parent + returnState;\n}\n\nfunction calculateEmptyHashString() {\n\treturn \"\";\n}\n\n// Used to cache {@link PredictionContext} objects. Its used for the shared\n// context cash associated with contexts in DFA states. This cache\n// can be used for both lexers and parsers.\n\nfunction PredictionContextCache() {\n\tthis.cache = {};\n\treturn this;\n}\n\n// Add a context to the cache and return it. If the context already exists,\n// return that one instead and do not add a new context to the cache.\n// Protect shared cache from unsafe thread access.\n//\nPredictionContextCache.prototype.add = function(ctx) {\n\tif (ctx === PredictionContext.EMPTY) {\n\t\treturn PredictionContext.EMPTY;\n\t}\n\tvar existing = this.cache[ctx] || null;\n\tif (existing !== null) {\n\t\treturn existing;\n\t}\n\tthis.cache[ctx] = ctx;\n\treturn ctx;\n};\n\nPredictionContextCache.prototype.get = function(ctx) {\n\treturn this.cache[ctx] || null;\n};\n\nObject.defineProperty(PredictionContextCache.prototype, \"length\", {\n\tget : function() {\n\t\treturn this.cache.length;\n\t}\n});\n\nfunction SingletonPredictionContext(parent, returnState) {\n\tvar hashString = parent !== null ? calculateHashString(parent, returnState)\n\t\t\t: calculateEmptyHashString();\n\tPredictionContext.call(this, hashString);\n\tthis.parentCtx = parent;\n\tthis.returnState = returnState;\n}\n\nSingletonPredictionContext.prototype = Object.create(PredictionContext.prototype);\nSingletonPredictionContext.prototype.contructor = SingletonPredictionContext;\n\nSingletonPredictionContext.create = function(parent, returnState) {\n\tif (returnState === PredictionContext.EMPTY_RETURN_STATE && parent === null) {\n\t\t// someone can pass in the bits of an array ctx that mean $\n\t\treturn PredictionContext.EMPTY;\n\t} else {\n\t\treturn new SingletonPredictionContext(parent, returnState);\n\t}\n};\n\nObject.defineProperty(SingletonPredictionContext.prototype, \"length\", {\n\tget : function() {\n\t\treturn 1;\n\t}\n});\n\nSingletonPredictionContext.prototype.getParent = function(index) {\n\treturn this.parentCtx;\n};\n\nSingletonPredictionContext.prototype.getReturnState = function(index) {\n\treturn this.returnState;\n};\n\nSingletonPredictionContext.prototype.equals = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof SingletonPredictionContext)) {\n\t\treturn false;\n\t} else if (this.hashString() !== other.hashString()) {\n\t\treturn false; // can't be same if hash is different\n\t} else {\n\t\tif(this.returnState !== other.returnState)\n            return false;\n        else if(this.parentCtx==null)\n            return other.parentCtx==null\n\t\telse\n            return this.parentCtx.equals(other.parentCtx);\n\t}\n};\n\nSingletonPredictionContext.prototype.hashString = function() {\n\treturn this.cachedHashString;\n};\n\nSingletonPredictionContext.prototype.toString = function() {\n\tvar up = this.parentCtx === null ? \"\" : this.parentCtx.toString();\n\tif (up.length === 0) {\n\t\tif (this.returnState === this.EMPTY_RETURN_STATE) {\n\t\t\treturn \"$\";\n\t\t} else {\n\t\t\treturn \"\" + this.returnState;\n\t\t}\n\t} else {\n\t\treturn \"\" + this.returnState + \" \" + up;\n\t}\n};\n\nfunction EmptyPredictionContext() {\n\tSingletonPredictionContext.call(this, null, PredictionContext.EMPTY_RETURN_STATE);\n\treturn this;\n}\n\nEmptyPredictionContext.prototype = Object.create(SingletonPredictionContext.prototype);\nEmptyPredictionContext.prototype.constructor = EmptyPredictionContext;\n\nEmptyPredictionContext.prototype.isEmpty = function() {\n\treturn true;\n};\n\nEmptyPredictionContext.prototype.getParent = function(index) {\n\treturn null;\n};\n\nEmptyPredictionContext.prototype.getReturnState = function(index) {\n\treturn this.returnState;\n};\n\nEmptyPredictionContext.prototype.equals = function(other) {\n\treturn this === other;\n};\n\nEmptyPredictionContext.prototype.toString = function() {\n\treturn \"$\";\n};\n\nPredictionContext.EMPTY = new EmptyPredictionContext();\n\nfunction ArrayPredictionContext(parents, returnStates) {\n\t// Parent can be null only if full ctx mode and we make an array\n\t// from {@link //EMPTY} and non-empty. We merge {@link //EMPTY} by using\n\t// null parent and\n\t// returnState == {@link //EMPTY_RETURN_STATE}.\n\tvar hash = calculateHashString(parents, returnStates);\n\tPredictionContext.call(this, hash);\n\tthis.parents = parents;\n\tthis.returnStates = returnStates;\n\treturn this;\n}\n\nArrayPredictionContext.prototype = Object.create(PredictionContext.prototype);\nArrayPredictionContext.prototype.constructor = ArrayPredictionContext;\n\nArrayPredictionContext.prototype.isEmpty = function() {\n\t// since EMPTY_RETURN_STATE can only appear in the last position, we\n\t// don't need to verify that size==1\n\treturn this.returnStates[0] === PredictionContext.EMPTY_RETURN_STATE;\n};\n\nObject.defineProperty(ArrayPredictionContext.prototype, \"length\", {\n\tget : function() {\n\t\treturn this.returnStates.length;\n\t}\n});\n\nArrayPredictionContext.prototype.getParent = function(index) {\n\treturn this.parents[index];\n};\n\nArrayPredictionContext.prototype.getReturnState = function(index) {\n\treturn this.returnStates[index];\n};\n\nArrayPredictionContext.prototype.equals = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof ArrayPredictionContext)) {\n\t\treturn false;\n\t} else if (this.hashString !== other.hashString()) {\n\t\treturn false; // can't be same if hash is different\n\t} else {\n\t\treturn this.returnStates === other.returnStates &&\n\t\t\t\tthis.parents === other.parents;\n\t}\n};\n\nArrayPredictionContext.prototype.toString = function() {\n\tif (this.isEmpty()) {\n\t\treturn \"[]\";\n\t} else {\n\t\tvar s = \"[\";\n\t\tfor (var i = 0; i < this.returnStates.length; i++) {\n\t\t\tif (i > 0) {\n\t\t\t\ts = s + \", \";\n\t\t\t}\n\t\t\tif (this.returnStates[i] === PredictionContext.EMPTY_RETURN_STATE) {\n\t\t\t\ts = s + \"$\";\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\ts = s + this.returnStates[i];\n\t\t\tif (this.parents[i] !== null) {\n\t\t\t\ts = s + \" \" + this.parents[i];\n\t\t\t} else {\n\t\t\t\ts = s + \"null\";\n\t\t\t}\n\t\t}\n\t\treturn s + \"]\";\n\t}\n};\n\n// Convert a {@link RuleContext} tree to a {@link PredictionContext} graph.\n// Return {@link //EMPTY} if {@code outerContext} is empty or null.\n// /\nfunction predictionContextFromRuleContext(atn, outerContext) {\n\tif (outerContext === undefined || outerContext === null) {\n\t\touterContext = RuleContext.EMPTY;\n\t}\n\t// if we are in RuleContext of start rule, s, then PredictionContext\n\t// is EMPTY. Nobody called us. (if we are empty, return empty)\n\tif (outerContext.parentCtx === null || outerContext === RuleContext.EMPTY) {\n\t\treturn PredictionContext.EMPTY;\n\t}\n\t// If we have a parent, convert it to a PredictionContext graph\n\tvar parent = predictionContextFromRuleContext(atn, outerContext.parentCtx);\n\tvar state = atn.states[outerContext.invokingState];\n\tvar transition = state.transitions[0];\n\treturn SingletonPredictionContext.create(parent, transition.followState.stateNumber);\n}\n\nfunction calculateListsHashString(parents, returnStates) {\n\tvar s = \"\";\n\tparents.map(function(p) {\n\t\ts = s + p;\n\t});\n\treturnStates.map(function(r) {\n\t\ts = s + r;\n\t});\n\treturn s;\n}\n\nfunction merge(a, b, rootIsWildcard, mergeCache) {\n\t// share same graph if both same\n\tif (a === b) {\n\t\treturn a;\n\t}\n\tif (a instanceof SingletonPredictionContext && b instanceof SingletonPredictionContext) {\n\t\treturn mergeSingletons(a, b, rootIsWildcard, mergeCache);\n\t}\n\t// At least one of a or b is array\n\t// If one is $ and rootIsWildcard, return $ as// wildcard\n\tif (rootIsWildcard) {\n\t\tif (a instanceof EmptyPredictionContext) {\n\t\t\treturn a;\n\t\t}\n\t\tif (b instanceof EmptyPredictionContext) {\n\t\t\treturn b;\n\t\t}\n\t}\n\t// convert singleton so both are arrays to normalize\n\tif (a instanceof SingletonPredictionContext) {\n\t\ta = new ArrayPredictionContext([a.getParent()], [a.returnState]);\n\t}\n\tif (b instanceof SingletonPredictionContext) {\n\t\tb = new ArrayPredictionContext([b.getParent()], [b.returnState]);\n\t}\n\treturn mergeArrays(a, b, rootIsWildcard, mergeCache);\n}\n\n//\n// Merge two {@link SingletonPredictionContext} instances.\n//\n// <p>Stack tops equal, parents merge is same; return left graph.<br>\n// <embed src=\"images/SingletonMerge_SameRootSamePar.svg\"\n// type=\"image/svg+xml\"/></p>\n//\n// <p>Same stack top, parents differ; merge parents giving array node, then\n// remainders of those graphs. A new root node is created to point to the\n// merged parents.<br>\n// <embed src=\"images/SingletonMerge_SameRootDiffPar.svg\"\n// type=\"image/svg+xml\"/></p>\n//\n// <p>Different stack tops pointing to same parent. Make array node for the\n// root where both element in the root point to the same (original)\n// parent.<br>\n// <embed src=\"images/SingletonMerge_DiffRootSamePar.svg\"\n// type=\"image/svg+xml\"/></p>\n//\n// <p>Different stack tops pointing to different parents. Make array node for\n// the root where each element points to the corresponding original\n// parent.<br>\n// <embed src=\"images/SingletonMerge_DiffRootDiffPar.svg\"\n// type=\"image/svg+xml\"/></p>\n//\n// @param a the first {@link SingletonPredictionContext}\n// @param b the second {@link SingletonPredictionContext}\n// @param rootIsWildcard {@code true} if this is a local-context merge,\n// otherwise false to indicate a full-context merge\n// @param mergeCache\n// /\nfunction mergeSingletons(a, b, rootIsWildcard, mergeCache) {\n\tif (mergeCache !== null) {\n\t\tvar previous = mergeCache.get(a, b);\n\t\tif (previous !== null) {\n\t\t\treturn previous;\n\t\t}\n\t\tprevious = mergeCache.get(b, a);\n\t\tif (previous !== null) {\n\t\t\treturn previous;\n\t\t}\n\t}\n\n\tvar rootMerge = mergeRoot(a, b, rootIsWildcard);\n\tif (rootMerge !== null) {\n\t\tif (mergeCache !== null) {\n\t\t\tmergeCache.set(a, b, rootMerge);\n\t\t}\n\t\treturn rootMerge;\n\t}\n\tif (a.returnState === b.returnState) {\n\t\tvar parent = merge(a.parentCtx, b.parentCtx, rootIsWildcard, mergeCache);\n\t\t// if parent is same as existing a or b parent or reduced to a parent,\n\t\t// return it\n\t\tif (parent === a.parentCtx) {\n\t\t\treturn a; // ax + bx = ax, if a=b\n\t\t}\n\t\tif (parent === b.parentCtx) {\n\t\t\treturn b; // ax + bx = bx, if a=b\n\t\t}\n\t\t// else: ax + ay = a'[x,y]\n\t\t// merge parents x and y, giving array node with x,y then remainders\n\t\t// of those graphs. dup a, a' points at merged array\n\t\t// new joined parent so create new singleton pointing to it, a'\n\t\tvar spc = SingletonPredictionContext.create(parent, a.returnState);\n\t\tif (mergeCache !== null) {\n\t\t\tmergeCache.set(a, b, spc);\n\t\t}\n\t\treturn spc;\n\t} else { // a != b payloads differ\n\t\t// see if we can collapse parents due to $+x parents if local ctx\n\t\tvar singleParent = null;\n\t\tif (a === b || (a.parentCtx !== null && a.parentCtx === b.parentCtx)) { // ax +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// bx =\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// [a,b]x\n\t\t\tsingleParent = a.parentCtx;\n\t\t}\n\t\tif (singleParent !== null) { // parents are same\n\t\t\t// sort payloads and use same parent\n\t\t\tvar payloads = [ a.returnState, b.returnState ];\n\t\t\tif (a.returnState > b.returnState) {\n\t\t\t\tpayloads[0] = b.returnState;\n\t\t\t\tpayloads[1] = a.returnState;\n\t\t\t}\n\t\t\tvar parents = [ singleParent, singleParent ];\n\t\t\tvar apc = new ArrayPredictionContext(parents, payloads);\n\t\t\tif (mergeCache !== null) {\n\t\t\t\tmergeCache.set(a, b, apc);\n\t\t\t}\n\t\t\treturn apc;\n\t\t}\n\t\t// parents differ and can't merge them. Just pack together\n\t\t// into array; can't merge.\n\t\t// ax + by = [ax,by]\n\t\tvar payloads = [ a.returnState, b.returnState ];\n\t\tvar parents = [ a.parentCtx, b.parentCtx ];\n\t\tif (a.returnState > b.returnState) { // sort by payload\n\t\t\tpayloads[0] = b.returnState;\n\t\t\tpayloads[1] = a.returnState;\n\t\t\tparents = [ b.parentCtx, a.parentCtx ];\n\t\t}\n\t\tvar a_ = new ArrayPredictionContext(parents, payloads);\n\t\tif (mergeCache !== null) {\n\t\t\tmergeCache.set(a, b, a_);\n\t\t}\n\t\treturn a_;\n\t}\n}\n\n//\n// Handle case where at least one of {@code a} or {@code b} is\n// {@link //EMPTY}. In the following diagrams, the symbol {@code $} is used\n// to represent {@link //EMPTY}.\n//\n// <h2>Local-Context Merges</h2>\n//\n// <p>These local-context merge operations are used when {@code rootIsWildcard}\n// is true.</p>\n//\n// <p>{@link //EMPTY} is superset of any graph; return {@link //EMPTY}.<br>\n// <embed src=\"images/LocalMerge_EmptyRoot.svg\" type=\"image/svg+xml\"/></p>\n//\n// <p>{@link //EMPTY} and anything is {@code //EMPTY}, so merged parent is\n// {@code //EMPTY}; return left graph.<br>\n// <embed src=\"images/LocalMerge_EmptyParent.svg\" type=\"image/svg+xml\"/></p>\n//\n// <p>Special case of last merge if local context.<br>\n// <embed src=\"images/LocalMerge_DiffRoots.svg\" type=\"image/svg+xml\"/></p>\n//\n// <h2>Full-Context Merges</h2>\n//\n// <p>These full-context merge operations are used when {@code rootIsWildcard}\n// is false.</p>\n//\n// <p><embed src=\"images/FullMerge_EmptyRoots.svg\" type=\"image/svg+xml\"/></p>\n//\n// <p>Must keep all contexts; {@link //EMPTY} in array is a special value (and\n// null parent).<br>\n// <embed src=\"images/FullMerge_EmptyRoot.svg\" type=\"image/svg+xml\"/></p>\n//\n// <p><embed src=\"images/FullMerge_SameRoot.svg\" type=\"image/svg+xml\"/></p>\n//\n// @param a the first {@link SingletonPredictionContext}\n// @param b the second {@link SingletonPredictionContext}\n// @param rootIsWildcard {@code true} if this is a local-context merge,\n// otherwise false to indicate a full-context merge\n// /\nfunction mergeRoot(a, b, rootIsWildcard) {\n\tif (rootIsWildcard) {\n\t\tif (a === PredictionContext.EMPTY) {\n\t\t\treturn PredictionContext.EMPTY; // // + b =//\n\t\t}\n\t\tif (b === PredictionContext.EMPTY) {\n\t\t\treturn PredictionContext.EMPTY; // a +// =//\n\t\t}\n\t} else {\n\t\tif (a === PredictionContext.EMPTY && b === PredictionContext.EMPTY) {\n\t\t\treturn PredictionContext.EMPTY; // $ + $ = $\n\t\t} else if (a === PredictionContext.EMPTY) { // $ + x = [$,x]\n\t\t\tvar payloads = [ b.returnState,\n\t\t\t\t\tPredictionContext.EMPTY_RETURN_STATE ];\n\t\t\tvar parents = [ b.parentCtx, null ];\n\t\t\treturn new ArrayPredictionContext(parents, payloads);\n\t\t} else if (b === PredictionContext.EMPTY) { // x + $ = [$,x] ($ is always first if present)\n\t\t\tvar payloads = [ a.returnState, PredictionContext.EMPTY_RETURN_STATE ];\n\t\t\tvar parents = [ a.parentCtx, null ];\n\t\t\treturn new ArrayPredictionContext(parents, payloads);\n\t\t}\n\t}\n\treturn null;\n}\n\n//\n// Merge two {@link ArrayPredictionContext} instances.\n//\n// <p>Different tops, different parents.<br>\n// <embed src=\"images/ArrayMerge_DiffTopDiffPar.svg\" type=\"image/svg+xml\"/></p>\n//\n// <p>Shared top, same parents.<br>\n// <embed src=\"images/ArrayMerge_ShareTopSamePar.svg\" type=\"image/svg+xml\"/></p>\n//\n// <p>Shared top, different parents.<br>\n// <embed src=\"images/ArrayMerge_ShareTopDiffPar.svg\" type=\"image/svg+xml\"/></p>\n//\n// <p>Shared top, all shared parents.<br>\n// <embed src=\"images/ArrayMerge_ShareTopSharePar.svg\"\n// type=\"image/svg+xml\"/></p>\n//\n// <p>Equal tops, merge parents and reduce top to\n// {@link SingletonPredictionContext}.<br>\n// <embed src=\"images/ArrayMerge_EqualTop.svg\" type=\"image/svg+xml\"/></p>\n// /\nfunction mergeArrays(a, b, rootIsWildcard, mergeCache) {\n\tif (mergeCache !== null) {\n\t\tvar previous = mergeCache.get(a, b);\n\t\tif (previous !== null) {\n\t\t\treturn previous;\n\t\t}\n\t\tprevious = mergeCache.get(b, a);\n\t\tif (previous !== null) {\n\t\t\treturn previous;\n\t\t}\n\t}\n\t// merge sorted payloads a + b => M\n\tvar i = 0; // walks a\n\tvar j = 0; // walks b\n\tvar k = 0; // walks target M array\n\n\tvar mergedReturnStates = [];\n\tvar mergedParents = [];\n\t// walk and merge to yield mergedParents, mergedReturnStates\n\twhile (i < a.returnStates.length && j < b.returnStates.length) {\n\t\tvar a_parent = a.parents[i];\n\t\tvar b_parent = b.parents[j];\n\t\tif (a.returnStates[i] === b.returnStates[j]) {\n\t\t\t// same payload (stack tops are equal), must yield merged singleton\n\t\t\tvar payload = a.returnStates[i];\n\t\t\t// $+$ = $\n\t\t\tvar bothDollars = payload === PredictionContext.EMPTY_RETURN_STATE &&\n\t\t\t\t\ta_parent === null && b_parent === null;\n\t\t\tvar ax_ax = (a_parent !== null && b_parent !== null && a_parent === b_parent); // ax+ax\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// ->\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// ax\n\t\t\tif (bothDollars || ax_ax) {\n\t\t\t\tmergedParents[k] = a_parent; // choose left\n\t\t\t\tmergedReturnStates[k] = payload;\n\t\t\t} else { // ax+ay -> a'[x,y]\n\t\t\t\tvar mergedParent = merge(a_parent, b_parent, rootIsWildcard, mergeCache);\n\t\t\t\tmergedParents[k] = mergedParent;\n\t\t\t\tmergedReturnStates[k] = payload;\n\t\t\t}\n\t\t\ti += 1; // hop over left one as usual\n\t\t\tj += 1; // but also skip one in right side since we merge\n\t\t} else if (a.returnStates[i] < b.returnStates[j]) { // copy a[i] to M\n\t\t\tmergedParents[k] = a_parent;\n\t\t\tmergedReturnStates[k] = a.returnStates[i];\n\t\t\ti += 1;\n\t\t} else { // b > a, copy b[j] to M\n\t\t\tmergedParents[k] = b_parent;\n\t\t\tmergedReturnStates[k] = b.returnStates[j];\n\t\t\tj += 1;\n\t\t}\n\t\tk += 1;\n\t}\n\t// copy over any payloads remaining in either array\n\tif (i < a.returnStates.length) {\n\t\tfor (var p = i; p < a.returnStates.length; p++) {\n\t\t\tmergedParents[k] = a.parents[p];\n\t\t\tmergedReturnStates[k] = a.returnStates[p];\n\t\t\tk += 1;\n\t\t}\n\t} else {\n\t\tfor (var p = j; p < b.returnStates.length; p++) {\n\t\t\tmergedParents[k] = b.parents[p];\n\t\t\tmergedReturnStates[k] = b.returnStates[p];\n\t\t\tk += 1;\n\t\t}\n\t}\n\t// trim merged if we combined a few that had same stack tops\n\tif (k < mergedParents.length) { // write index < last position; trim\n\t\tif (k === 1) { // for just one merged element, return singleton top\n\t\t\tvar a_ = SingletonPredictionContext.create(mergedParents[0],\n\t\t\t\t\tmergedReturnStates[0]);\n\t\t\tif (mergeCache !== null) {\n\t\t\t\tmergeCache.set(a, b, a_);\n\t\t\t}\n\t\t\treturn a_;\n\t\t}\n\t\tmergedParents = mergedParents.slice(0, k);\n\t\tmergedReturnStates = mergedReturnStates.slice(0, k);\n\t}\n\n\tvar M = new ArrayPredictionContext(mergedParents, mergedReturnStates);\n\n\t// if we created same array as a or b, return that instead\n\t// TODO: track whether this is possible above during merge sort for speed\n\tif (M === a) {\n\t\tif (mergeCache !== null) {\n\t\t\tmergeCache.set(a, b, a);\n\t\t}\n\t\treturn a;\n\t}\n\tif (M === b) {\n\t\tif (mergeCache !== null) {\n\t\t\tmergeCache.set(a, b, b);\n\t\t}\n\t\treturn b;\n\t}\n\tcombineCommonParents(mergedParents);\n\n\tif (mergeCache !== null) {\n\t\tmergeCache.set(a, b, M);\n\t}\n\treturn M;\n}\n\n//\n// Make pass over all <em>M</em> {@code parents}; merge any {@code equals()}\n// ones.\n// /\nfunction combineCommonParents(parents) {\n\tvar uniqueParents = {};\n\n\tfor (var p = 0; p < parents.length; p++) {\n\t\tvar parent = parents[p];\n\t\tif (!(parent in uniqueParents)) {\n\t\t\tuniqueParents[parent] = parent;\n\t\t}\n\t}\n\tfor (var q = 0; q < parents.length; q++) {\n\t\tparents[q] = uniqueParents[parents[q]];\n\t}\n}\n\nfunction getCachedPredictionContext(context, contextCache, visited) {\n\tif (context.isEmpty()) {\n\t\treturn context;\n\t}\n\tvar existing = visited[context] || null;\n\tif (existing !== null) {\n\t\treturn existing;\n\t}\n\texisting = contextCache.get(context);\n\tif (existing !== null) {\n\t\tvisited[context] = existing;\n\t\treturn existing;\n\t}\n\tvar changed = false;\n\tvar parents = [];\n\tfor (var i = 0; i < parents.length; i++) {\n\t\tvar parent = getCachedPredictionContext(context.getParent(i), contextCache, visited);\n\t\tif (changed || parent !== context.getParent(i)) {\n\t\t\tif (!changed) {\n\t\t\t\tparents = [];\n\t\t\t\tfor (var j = 0; j < context.length; j++) {\n\t\t\t\t\tparents[j] = context.getParent(j);\n\t\t\t\t}\n\t\t\t\tchanged = true;\n\t\t\t}\n\t\t\tparents[i] = parent;\n\t\t}\n\t}\n\tif (!changed) {\n\t\tcontextCache.add(context);\n\t\tvisited[context] = context;\n\t\treturn context;\n\t}\n\tvar updated = null;\n\tif (parents.length === 0) {\n\t\tupdated = PredictionContext.EMPTY;\n\t} else if (parents.length === 1) {\n\t\tupdated = SingletonPredictionContext.create(parents[0], context\n\t\t\t\t.getReturnState(0));\n\t} else {\n\t\tupdated = new ArrayPredictionContext(parents, context.returnStates);\n\t}\n\tcontextCache.add(updated);\n\tvisited[updated] = updated;\n\tvisited[context] = updated;\n\n\treturn updated;\n}\n\n// ter's recursive version of Sam's getAllNodes()\nfunction getAllContextNodes(context, nodes, visited) {\n\tif (nodes === null) {\n\t\tnodes = [];\n\t\treturn getAllContextNodes(context, nodes, visited);\n\t} else if (visited === null) {\n\t\tvisited = {};\n\t\treturn getAllContextNodes(context, nodes, visited);\n\t} else {\n\t\tif (context === null || visited[context] !== null) {\n\t\t\treturn nodes;\n\t\t}\n\t\tvisited[context] = context;\n\t\tnodes.push(context);\n\t\tfor (var i = 0; i < context.length; i++) {\n\t\t\tgetAllContextNodes(context.getParent(i), nodes, visited);\n\t\t}\n\t\treturn nodes;\n\t}\n}\n\nexports.merge = merge;\nexports.PredictionContext = PredictionContext;\nexports.PredictionContextCache = PredictionContextCache;\nexports.SingletonPredictionContext = SingletonPredictionContext;\nexports.predictionContextFromRuleContext = predictionContextFromRuleContext;\nexports.getCachedPredictionContext = getCachedPredictionContext;\n\n},{\"./RuleContext\":13}],12:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\nvar Token = require('./Token').Token;\nvar ConsoleErrorListener = require('./error/ErrorListener').ConsoleErrorListener;\nvar ProxyErrorListener = require('./error/ErrorListener').ProxyErrorListener;\n\nfunction Recognizer() {\n    this._listeners = [ ConsoleErrorListener.INSTANCE ];\n    this._interp = null;\n    this._stateNumber = -1;\n    return this;\n}\n\nRecognizer.tokenTypeMapCache = {};\nRecognizer.ruleIndexMapCache = {};\n\n\nRecognizer.prototype.checkVersion = function(toolVersion) {\n    var runtimeVersion = \"4.5.3\";\n    if (runtimeVersion!==toolVersion) {\n        console.log(\"ANTLR runtime and generated code versions disagree: \"+runtimeVersion+\"!=\"+toolVersion);\n    }\n};\n\nRecognizer.prototype.addErrorListener = function(listener) {\n    this._listeners.push(listener);\n};\n\nRecognizer.prototype.removeErrorListeners = function() {\n    this._listeners = [];\n};\n\nRecognizer.prototype.getTokenTypeMap = function() {\n    var tokenNames = this.getTokenNames();\n    if (tokenNames===null) {\n        throw(\"The current recognizer does not provide a list of token names.\");\n    }\n    var result = this.tokenTypeMapCache[tokenNames];\n    if(result===undefined) {\n        result = tokenNames.reduce(function(o, k, i) { o[k] = i; });\n        result.EOF = Token.EOF;\n        this.tokenTypeMapCache[tokenNames] = result;\n    }\n    return result;\n};\n\n// Get a map from rule names to rule indexes.\n//\n// <p>Used for XPath and tree pattern compilation.</p>\n//\nRecognizer.prototype.getRuleIndexMap = function() {\n    var ruleNames = this.getRuleNames();\n    if (ruleNames===null) {\n        throw(\"The current recognizer does not provide a list of rule names.\");\n    }\n    var result = this.ruleIndexMapCache[ruleNames];\n    if(result===undefined) {\n        result = ruleNames.reduce(function(o, k, i) { o[k] = i; });\n        this.ruleIndexMapCache[ruleNames] = result;\n    }\n    return result;\n};\n\nRecognizer.prototype.getTokenType = function(tokenName) {\n    var ttype = this.getTokenTypeMap()[tokenName];\n    if (ttype !==undefined) {\n        return ttype;\n    } else {\n        return Token.INVALID_TYPE;\n    }\n};\n\n\n// What is the error header, normally line/character position information?//\nRecognizer.prototype.getErrorHeader = function(e) {\n    var line = e.getOffendingToken().line;\n    var column = e.getOffendingToken().column;\n    return \"line \" + line + \":\" + column;\n};\n\n\n// How should a token be displayed in an error message? The default\n//  is to display just the text, but during development you might\n//  want to have a lot of information spit out.  Override in that case\n//  to use t.toString() (which, for CommonToken, dumps everything about\n//  the token). This is better than forcing you to override a method in\n//  your token objects because you don't have to go modify your lexer\n//  so that it creates a new Java type.\n//\n// @deprecated This method is not called by the ANTLR 4 Runtime. Specific\n// implementations of {@link ANTLRErrorStrategy} may provide a similar\n// feature when necessary. For example, see\n// {@link DefaultErrorStrategy//getTokenErrorDisplay}.\n//\nRecognizer.prototype.getTokenErrorDisplay = function(t) {\n    if (t===null) {\n        return \"<no token>\";\n    }\n    var s = t.text;\n    if (s===null) {\n        if (t.type===Token.EOF) {\n            s = \"<EOF>\";\n        } else {\n            s = \"<\" + t.type + \">\";\n        }\n    }\n    s = s.replace(\"\\n\",\"\\\\n\").replace(\"\\r\",\"\\\\r\").replace(\"\\t\",\"\\\\t\");\n    return \"'\" + s + \"'\";\n};\n\nRecognizer.prototype.getErrorListenerDispatch = function() {\n    return new ProxyErrorListener(this._listeners);\n};\n\n// subclass needs to override these if there are sempreds or actions\n// that the ATN interp needs to execute\nRecognizer.prototype.sempred = function(localctx, ruleIndex, actionIndex) {\n    return true;\n};\n\nRecognizer.prototype.precpred = function(localctx , precedence) {\n    return true;\n};\n\n//Indicate that the recognizer has changed internal state that is\n//consistent with the ATN state passed in.  This way we always know\n//where we are in the ATN as the parser goes along. The rule\n//context objects form a stack that lets us see the stack of\n//invoking rules. Combine this and we have complete ATN\n//configuration information.\n\nObject.defineProperty(Recognizer.prototype, \"state\", {\n\tget : function() {\n\t\treturn this._stateNumber;\n\t},\n\tset : function(state) {\n\t\tthis._stateNumber = state;\n\t}\n});\n\n\nexports.Recognizer = Recognizer;\n\n},{\"./Token\":14,\"./error/ErrorListener\":37}],13:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2013 Terence Parr\n//  Copyright (c) 2013 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n//  A rule context is a record of a single rule invocation. It knows\n//  which context invoked it, if any. If there is no parent context, then\n//  naturally the invoking state is not valid.  The parent link\n//  provides a chain upwards from the current rule invocation to the root\n//  of the invocation tree, forming a stack. We actually carry no\n//  information about the rule associated with this context (except\n//  when parsing). We keep only the state number of the invoking state from\n//  the ATN submachine that invoked this. Contrast this with the s\n//  pointer inside ParserRuleContext that tracks the current state\n//  being \"executed\" for the current rule.\n//\n//  The parent contexts are useful for computing lookahead sets and\n//  getting error information.\n//\n//  These objects are used during parsing and prediction.\n//  For the special case of parsers, we use the subclass\n//  ParserRuleContext.\n//\n//  @see ParserRuleContext\n///\n\nvar RuleNode = require('./tree/Tree').RuleNode;\nvar INVALID_INTERVAL = require('./tree/Tree').INVALID_INTERVAL;\nvar INVALID_ALT_NUMBER = require('./atn/ATN').INVALID_ALT_NUMBER;\n\nfunction RuleContext(parent, invokingState) {\n\tRuleNode.call(this);\n\t// What context invoked this rule?\n\tthis.parentCtx = parent || null;\n\t// What state invoked the rule associated with this context?\n\t// The \"return address\" is the followState of invokingState\n\t// If parent is null, this should be -1.\n\tthis.invokingState = invokingState || -1;\n\treturn this;\n}\n\nRuleContext.prototype = Object.create(RuleNode.prototype);\nRuleContext.prototype.constructor = RuleContext;\n\nRuleContext.prototype.depth = function() {\n\tvar n = 0;\n\tvar p = this;\n\twhile (p !== null) {\n\t\tp = p.parentCtx;\n\t\tn += 1;\n\t}\n\treturn n;\n};\n\n// A context is empty if there is no invoking state; meaning nobody call\n// current context.\nRuleContext.prototype.isEmpty = function() {\n\treturn this.invokingState === -1;\n};\n\n// satisfy the ParseTree / SyntaxTree interface\n\nRuleContext.prototype.getSourceInterval = function() {\n\treturn INVALID_INTERVAL;\n};\n\nRuleContext.prototype.getRuleContext = function() {\n\treturn this;\n};\n\nRuleContext.prototype.getPayload = function() {\n\treturn this;\n};\n\n// Return the combined text of all child nodes. This method only considers\n// tokens which have been added to the parse tree.\n// <p>\n// Since tokens on hidden channels (e.g. whitespace or comments) are not\n// added to the parse trees, they will not appear in the output of this\n// method.\n// /\nRuleContext.prototype.getText = function() {\n\tif (this.getChildCount() === 0) {\n\t\treturn \"\";\n\t} else {\n\t\treturn this.children.map(function(child) {\n\t\t\treturn child.getText();\n\t\t}).join(\"\");\n\t}\n};\n\n// For rule associated with this parse tree internal node, return\n// the outer alternative number used to match the input. Default\n// implementation does not compute nor store this alt num. Create\n// a subclass of ParserRuleContext with backing field and set\n// option contextSuperClass.\n// to set it.\nRuleContext.prototype.getAltNumber = function() { return INVALID_ALT_NUMBER; }\n\n// Set the outer alternative number for this context node. Default\n// implementation does nothing to avoid backing field overhead for\n// trees that don't need it.  Create\n// a subclass of ParserRuleContext with backing field and set\n// option contextSuperClass.\nRuleContext.prototype.setAltNumber = function(altNumber) { }\n\nRuleContext.prototype.getChild = function(i) {\n\treturn null;\n};\n\nRuleContext.prototype.getChildCount = function() {\n\treturn 0;\n};\n\nRuleContext.prototype.accept = function(visitor) {\n\treturn visitor.visitChildren(this);\n};\n\n//need to manage circular dependencies, so export now\nexports.RuleContext = RuleContext;\nvar Trees = require('./tree/Trees').Trees;\n\n\n// Print out a whole tree, not just a node, in LISP format\n// (root child1 .. childN). Print just a node if this is a leaf.\n//\n\nRuleContext.prototype.toStringTree = function(ruleNames, recog) {\n\treturn Trees.toStringTree(this, ruleNames, recog);\n};\n\nRuleContext.prototype.toString = function(ruleNames, stop) {\n\truleNames = ruleNames || null;\n\tstop = stop || null;\n\tvar p = this;\n\tvar s = \"[\";\n\twhile (p !== null && p !== stop) {\n\t\tif (ruleNames === null) {\n\t\t\tif (!p.isEmpty()) {\n\t\t\t\ts += p.invokingState;\n\t\t\t}\n\t\t} else {\n\t\t\tvar ri = p.ruleIndex;\n\t\t\tvar ruleName = (ri >= 0 && ri < ruleNames.length) ? ruleNames[ri]\n\t\t\t\t\t: \"\" + ri;\n\t\t\ts += ruleName;\n\t\t}\n\t\tif (p.parentCtx !== null && (ruleNames !== null || !p.parentCtx.isEmpty())) {\n\t\t\ts += \" \";\n\t\t}\n\t\tp = p.parentCtx;\n\t}\n\ts += \"]\";\n\treturn s;\n};\n\n\n},{\"./atn/ATN\":16,\"./tree/Tree\":42,\"./tree/Trees\":43}],14:[function(require,module,exports){\n//[The \"BSD license\"]\n// Copyright (c) 2012 Terence Parr\n// Copyright (c) 2012 Sam Harwell\n// Copyright (c) 2014 Eric Vergnaud\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions\n// are met:\n//\n// 1. Redistributions of source code must retain the above copyright\n//    notice, this list of conditions and the following disclaimer.\n// 2. Redistributions in binary form must reproduce the above copyright\n//    notice, this list of conditions and the following disclaimer in the\n//    documentation and/or other materials provided with the distribution.\n// 3. The name of the author may not be used to endorse or promote products\n//    derived from this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n// A token has properties: text, type, line, character position in the line\n// (so we can ignore tabs), token channel, index, and source from which\n// we obtained this token.\n\nfunction Token() {\n\tthis.source = null;\n\tthis.type = null; // token type of the token\n\tthis.channel = null; // The parser ignores everything not on DEFAULT_CHANNEL\n\tthis.start = null; // optional; return -1 if not implemented.\n\tthis.stop = null; // optional; return -1 if not implemented.\n\tthis.tokenIndex = null; // from 0..n-1 of the token object in the input stream\n\tthis.line = null; // line=1..n of the 1st character\n\tthis.column = null; // beginning of the line at which it occurs, 0..n-1\n\tthis._text = null; // text of the token.\n\treturn this;\n}\n\nToken.INVALID_TYPE = 0;\n\n// During lookahead operations, this \"token\" signifies we hit rule end ATN state\n// and did not follow it despite needing to.\nToken.EPSILON = -2;\n\nToken.MIN_USER_TOKEN_TYPE = 1;\n\nToken.EOF = -1;\n\n// All tokens go to the parser (unless skip() is called in that rule)\n// on a particular \"channel\". The parser tunes to a particular channel\n// so that whitespace etc... can go to the parser on a \"hidden\" channel.\n\nToken.DEFAULT_CHANNEL = 0;\n\n// Anything on different channel than DEFAULT_CHANNEL is not parsed\n// by parser.\n\nToken.HIDDEN_CHANNEL = 1;\n\n// Explicitly set the text for this token. If {code text} is not\n// {@code null}, then {@link //getText} will return this value rather than\n// extracting the text from the input.\n//\n// @param text The explicit text of the token, or {@code null} if the text\n// should be obtained from the input along with the start and stop indexes\n// of the token.\n\nObject.defineProperty(Token.prototype, \"text\", {\n\tget : function() {\n\t\treturn this._text;\n\t},\n\tset : function(text) {\n\t\tthis._text = text;\n\t}\n});\n\nToken.prototype.getTokenSource = function() {\n\treturn this.source[0];\n};\n\nToken.prototype.getInputStream = function() {\n\treturn this.source[1];\n};\n\nfunction CommonToken(source, type, channel, start, stop) {\n\tToken.call(this);\n\tthis.source = source !== undefined ? source : CommonToken.EMPTY_SOURCE;\n\tthis.type = type !== undefined ? type : null;\n\tthis.channel = channel !== undefined ? channel : Token.DEFAULT_CHANNEL;\n\tthis.start = start !== undefined ? start : -1;\n\tthis.stop = stop !== undefined ? stop : -1;\n\tthis.tokenIndex = -1;\n\tif (this.source[0] !== null) {\n\t\tthis.line = source[0].line;\n\t\tthis.column = source[0].column;\n\t} else {\n\t\tthis.column = -1;\n\t}\n\treturn this;\n}\n\nCommonToken.prototype = Object.create(Token.prototype);\nCommonToken.prototype.constructor = CommonToken;\n\n// An empty {@link Pair} which is used as the default value of\n// {@link //source} for tokens that do not have a source.\nCommonToken.EMPTY_SOURCE = [ null, null ];\n\n// Constructs a new {@link CommonToken} as a copy of another {@link Token}.\n//\n// <p>\n// If {@code oldToken} is also a {@link CommonToken} instance, the newly\n// constructed token will share a reference to the {@link //text} field and\n// the {@link Pair} stored in {@link //source}. Otherwise, {@link //text} will\n// be assigned the result of calling {@link //getText}, and {@link //source}\n// will be constructed from the result of {@link Token//getTokenSource} and\n// {@link Token//getInputStream}.</p>\n//\n// @param oldToken The token to copy.\n//\nCommonToken.prototype.clone = function() {\n\tvar t = new CommonToken(this.source, this.type, this.channel, this.start,\n\t\t\tthis.stop);\n\tt.tokenIndex = this.tokenIndex;\n\tt.line = this.line;\n\tt.column = this.column;\n\tt.text = this.text;\n\treturn t;\n};\n\nObject.defineProperty(CommonToken.prototype, \"text\", {\n\tget : function() {\n\t\tif (this._text !== null) {\n\t\t\treturn this._text;\n\t\t}\n\t\tvar input = this.getInputStream();\n\t\tif (input === null) {\n\t\t\treturn null;\n\t\t}\n\t\tvar n = input.size;\n\t\tif (this.start < n && this.stop < n) {\n\t\t\treturn input.getText(this.start, this.stop);\n\t\t} else {\n\t\t\treturn \"<EOF>\";\n\t\t}\n\t},\n\tset : function(text) {\n\t\tthis._text = text;\n\t}\n});\n\nCommonToken.prototype.toString = function() {\n\tvar txt = this.text;\n\tif (txt !== null) {\n\t\ttxt = txt.replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\").replace(/\\t/g, \"\\\\t\");\n\t} else {\n\t\ttxt = \"<no text>\";\n\t}\n\treturn \"[@\" + this.tokenIndex + \",\" + this.start + \":\" + this.stop + \"='\" +\n\t\t\ttxt + \"',<\" + this.type + \">\" +\n\t\t\t(this.channel > 0 ? \",channel=\" + this.channel : \"\") + \",\" +\n\t\t\tthis.line + \":\" + this.column + \"]\";\n};\n\nexports.Token = Token;\nexports.CommonToken = CommonToken;\n\n},{}],15:[function(require,module,exports){\nfunction arrayToString(a) {\n\treturn \"[\" + a.join(\", \") + \"]\";\n}\n\nString.prototype.hashCode = function(s) {\n\tvar hash = 0;\n\tif (this.length === 0) {\n\t\treturn hash;\n\t}\n\tfor (var i = 0; i < this.length; i++) {\n\t\tvar character = this.charCodeAt(i);\n\t\thash = ((hash << 5) - hash) + character;\n\t\thash = hash & hash; // Convert to 32bit integer\n\t}\n\treturn hash;\n};\n\nfunction standardEqualsFunction(a,b) {\n\treturn a.equals(b);\n}\n\nfunction standardHashFunction(a) {\n\treturn a.hashString();\n}\n\nfunction Set(hashFunction, equalsFunction) {\n\tthis.data = {};\n\tthis.hashFunction = hashFunction || standardHashFunction;\n\tthis.equalsFunction = equalsFunction || standardEqualsFunction;\n\treturn this;\n}\n\nObject.defineProperty(Set.prototype, \"length\", {\n\tget : function() {\n\t\treturn this.values().length;\n\t}\n});\n\nSet.prototype.add = function(value) {\n\tvar hash = this.hashFunction(value);\n\tvar key = \"hash_\" + hash.hashCode();\n\tif(key in this.data) {\n\t\tvar i;\n\t\tvar values = this.data[key];\n\t\tfor(i=0;i<values.length; i++) {\n\t\t\tif(this.equalsFunction(value, values[i])) {\n\t\t\t\treturn values[i];\n\t\t\t}\n\t\t}\n\t\tvalues.push(value);\n\t\treturn value;\n\t} else {\n\t\tthis.data[key] = [ value ];\n\t\treturn value;\n\t}\n};\n\nSet.prototype.contains = function(value) {\n\tvar hash = this.hashFunction(value);\n\tvar key = hash.hashCode();\n\tif(key in this.data) {\n\t\tvar i;\n\t\tvar values = this.data[key];\n\t\tfor(i=0;i<values.length; i++) {\n\t\t\tif(this.equalsFunction(value, values[i])) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t}\n\treturn false;\n};\n\nSet.prototype.values = function() {\n\tvar l = [];\n\tfor(var key in this.data) {\n\t\tif(key.indexOf(\"hash_\")===0) {\n\t\t\tl = l.concat(this.data[key]);\n\t\t}\n\t}\n\treturn l;\n};\n\nSet.prototype.toString = function() {\n\treturn arrayToString(this.values());\n};\n\nfunction BitSet() {\n\tthis.data = [];\n\treturn this;\n}\n\nBitSet.prototype.add = function(value) {\n\tthis.data[value] = true;\n};\n\nBitSet.prototype.or = function(set) {\n\tvar bits = this;\n\tObject.keys(set.data).map( function(alt) { bits.add(alt); });\n};\n\nBitSet.prototype.remove = function(value) {\n\tdelete this.data[value];\n};\n\nBitSet.prototype.contains = function(value) {\n\treturn this.data[value] === true;\n};\n\nBitSet.prototype.values = function() {\n\treturn Object.keys(this.data);\n};\n\nBitSet.prototype.minValue = function() {\n\treturn Math.min.apply(null, this.values());\n};\n\nBitSet.prototype.hashString = function() {\n\treturn this.values().toString();\n};\n\nBitSet.prototype.equals = function(other) {\n\tif(!(other instanceof BitSet)) {\n\t\treturn false;\n\t}\n\treturn this.hashString()===other.hashString();\n};\n\nObject.defineProperty(BitSet.prototype, \"length\", {\n\tget : function() {\n\t\treturn this.values().length;\n\t}\n});\n\nBitSet.prototype.toString = function() {\n\treturn \"{\" + this.values().join(\", \") + \"}\";\n};\n\nfunction AltDict() {\n\tthis.data = {};\n\treturn this;\n}\n\nAltDict.prototype.get = function(key) {\n\tkey = \"k-\" + key;\n\tif(key in this.data){\n\t\treturn this.data[key];\n\t} else {\n\t\treturn null;\n\t}\n};\n\nAltDict.prototype.put = function(key, value) {\n\tkey = \"k-\" + key;\n\tthis.data[key] = value;\n};\n\nAltDict.prototype.values = function() {\n\tvar data = this.data;\n\tvar keys = Object.keys(this.data);\n\treturn keys.map(function(key) {\n\t\treturn data[key];\n\t});\n};\n\nfunction DoubleDict() {\n\treturn this;\n}\n\nDoubleDict.prototype.get = function(a, b) {\n\tvar d = this[a] || null;\n\treturn d===null ? null : (d[b] || null);\n};\n\nDoubleDict.prototype.set = function(a, b, o) {\n\tvar d = this[a] || null;\n\tif(d===null) {\n\t\td = {};\n\t\tthis[a] = d;\n\t}\n\td[b] = o;\n};\n\n\nfunction escapeWhitespace(s, escapeSpaces) {\n\ts = s.replace(\"\\t\",\"\\\\t\");\n\ts = s.replace(\"\\n\",\"\\\\n\");\n\ts = s.replace(\"\\r\",\"\\\\r\");\n\tif(escapeSpaces) {\n\t\ts = s.replace(\" \",\"\\u00B7\");\n\t}\n\treturn s;\n}\n\nexports.isArray = function (entity) {\n\treturn Object.prototype.toString.call( entity ) === '[object Array]'\n};\n\nexports.titleCase = function(str) {\n\treturn str.replace(/\\w\\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1);});\n};\n\nexports.Set = Set;\nexports.BitSet = BitSet;\nexports.AltDict = AltDict;\nexports.DoubleDict = DoubleDict;\nexports.escapeWhitespace = escapeWhitespace;\nexports.arrayToString = arrayToString;\n\n},{}],16:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2013 Terence Parr\n//  Copyright (c) 2013 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nvar LL1Analyzer = require('./../LL1Analyzer').LL1Analyzer;\nvar IntervalSet = require('./../IntervalSet').IntervalSet;\n\nfunction ATN(grammarType , maxTokenType) {\n\n    // Used for runtime deserialization of ATNs from strings///\n    // The type of the ATN.\n    this.grammarType = grammarType;\n    // The maximum value for any symbol recognized by a transition in the ATN.\n    this.maxTokenType = maxTokenType;\n    this.states = [];\n    // Each subrule/rule is a decision point and we must track them so we\n    //  can go back later and build DFA predictors for them.  This includes\n    //  all the rules, subrules, optional blocks, ()+, ()* etc...\n    this.decisionToState = [];\n    // Maps from rule index to starting state number.\n    this.ruleToStartState = [];\n    // Maps from rule index to stop state number.\n    this.ruleToStopState = null;\n    this.modeNameToStartState = {};\n    // For lexer ATNs, this maps the rule index to the resulting token type.\n    // For parser ATNs, this maps the rule index to the generated bypass token\n    // type if the\n    // {@link ATNDeserializationOptions//isGenerateRuleBypassTransitions}\n    // deserialization option was specified; otherwise, this is {@code null}.\n    this.ruleToTokenType = null;\n    // For lexer ATNs, this is an array of {@link LexerAction} objects which may\n    // be referenced by action transitions in the ATN.\n    this.lexerActions = null;\n    this.modeToStartState = [];\n\n    return this;\n}\n\t\n// Compute the set of valid tokens that can occur starting in state {@code s}.\n//  If {@code ctx} is null, the set of tokens will not include what can follow\n//  the rule surrounding {@code s}. In other words, the set will be\n//  restricted to tokens reachable staying within {@code s}'s rule.\nATN.prototype.nextTokensInContext = function(s, ctx) {\n    var anal = new LL1Analyzer(this);\n    return anal.LOOK(s, null, ctx);\n};\n\n// Compute the set of valid tokens that can occur starting in {@code s} and\n// staying in same rule. {@link Token//EPSILON} is in set if we reach end of\n// rule.\nATN.prototype.nextTokensNoContext = function(s) {\n    if (s.nextTokenWithinRule !== null ) {\n        return s.nextTokenWithinRule;\n    }\n    s.nextTokenWithinRule = this.nextTokensInContext(s, null);\n    s.nextTokenWithinRule.readOnly = true;\n    return s.nextTokenWithinRule;\n};\n\nATN.prototype.nextTokens = function(s, ctx) {\n    if ( ctx===undefined ) {\n        return this.nextTokensNoContext(s);\n    } else {\n        return this.nextTokensInContext(s, ctx);\n    }\n};\n\nATN.prototype.addState = function( state) {\n    if ( state !== null ) {\n        state.atn = this;\n        state.stateNumber = this.states.length;\n    }\n    this.states.push(state);\n};\n\nATN.prototype.removeState = function( state) {\n    this.states[state.stateNumber] = null; // just free mem, don't shift states in list\n};\n\nATN.prototype.defineDecisionState = function( s) {\n    this.decisionToState.push(s);\n    s.decision = this.decisionToState.length-1;\n    return s.decision;\n};\n\nATN.prototype.getDecisionState = function( decision) {\n    if (this.decisionToState.length===0) {\n        return null;\n    } else {\n        return this.decisionToState[decision];\n    }\n};\n\n// Computes the set of input symbols which could follow ATN state number\n// {@code stateNumber} in the specified full {@code context}. This method\n// considers the complete parser context, but does not evaluate semantic\n// predicates (i.e. all predicates encountered during the calculation are\n// assumed true). If a path in the ATN exists from the starting state to the\n// {@link RuleStopState} of the outermost context without matching any\n// symbols, {@link Token//EOF} is added to the returned set.\n//\n// <p>If {@code context} is {@code null}, it is treated as\n// {@link ParserRuleContext//EMPTY}.</p>\n//\n// @param stateNumber the ATN state number\n// @param context the full parse context\n// @return The set of potentially valid input symbols which could follow the\n// specified state in the specified context.\n// @throws IllegalArgumentException if the ATN does not contain a state with\n// number {@code stateNumber}\nvar Token = require('./../Token').Token;\n\nATN.prototype.getExpectedTokens = function( stateNumber, ctx ) {\n    if ( stateNumber < 0 || stateNumber >= this.states.length ) {\n        throw(\"Invalid state number.\");\n    }\n    var s = this.states[stateNumber];\n    var following = this.nextTokens(s);\n    if (!following.contains(Token.EPSILON)) {\n        return following;\n    }\n    var expected = new IntervalSet();\n    expected.addSet(following);\n    expected.removeOne(Token.EPSILON);\n    while (ctx !== null && ctx.invokingState >= 0 && following.contains(Token.EPSILON)) {\n        var invokingState = this.states[ctx.invokingState];\n        var rt = invokingState.transitions[0];\n        following = this.nextTokens(rt.followState);\n        expected.addSet(following);\n        expected.removeOne(Token.EPSILON);\n        ctx = ctx.parentCtx;\n    }\n    if (following.contains(Token.EPSILON)) {\n        expected.addOne(Token.EOF);\n    }\n    return expected;\n};\n\nATN.INVALID_ALT_NUMBER = 0;\n\nexports.ATN = ATN;\n},{\"./../IntervalSet\":6,\"./../LL1Analyzer\":7,\"./../Token\":14}],17:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n// A tuple: (ATN state, predicted alt, syntactic, semantic context).\n//  The syntactic context is a graph-structured stack node whose\n//  path(s) to the root is the rule invocation(s)\n//  chain used to arrive at the state.  The semantic context is\n//  the tree of semantic predicates encountered before reaching\n//  an ATN state.\n///\n\nvar DecisionState = require('./ATNState').DecisionState;\nvar SemanticContext = require('./SemanticContext').SemanticContext;\n\nfunction checkParams(params, isCfg) {\n\tif(params===null) {\n\t\tvar result = { state:null, alt:null, context:null, semanticContext:null };\n\t\tif(isCfg) {\n\t\t\tresult.reachesIntoOuterContext = 0;\n\t\t}\n\t\treturn result;\n\t} else {\n\t\tvar props = {};\n\t\tprops.state = params.state || null;\n\t\tprops.alt = (params.alt === undefined) ? null : params.alt;\n\t\tprops.context = params.context || null;\n\t\tprops.semanticContext = params.semanticContext || null;\n\t\tif(isCfg) {\n\t\t\tprops.reachesIntoOuterContext = params.reachesIntoOuterContext || 0;\n\t\t\tprops.precedenceFilterSuppressed = params.precedenceFilterSuppressed || false;\n\t\t}\n\t\treturn props;\n\t}\n}\n\nfunction ATNConfig(params, config) {\n\tthis.checkContext(params, config);\n\tparams = checkParams(params);\n\tconfig = checkParams(config, true);\n    // The ATN state associated with this configuration///\n    this.state = params.state!==null ? params.state : config.state;\n    // What alt (or lexer rule) is predicted by this configuration///\n    this.alt = params.alt!==null ? params.alt : config.alt;\n    // The stack of invoking states leading to the rule/states associated\n    //  with this config.  We track only those contexts pushed during\n    //  execution of the ATN simulator.\n    this.context = params.context!==null ? params.context : config.context;\n    this.semanticContext = params.semanticContext!==null ? params.semanticContext :\n        (config.semanticContext!==null ? config.semanticContext : SemanticContext.NONE);\n    // We cannot execute predicates dependent upon local context unless\n    // we know for sure we are in the correct context. Because there is\n    // no way to do this efficiently, we simply cannot evaluate\n    // dependent predicates unless we are in the rule that initially\n    // invokes the ATN simulator.\n    //\n    // closure() tracks the depth of how far we dip into the\n    // outer context: depth &gt; 0.  Note that it may not be totally\n    // accurate depth since I don't ever decrement. TODO: make it a boolean then\n    this.reachesIntoOuterContext = config.reachesIntoOuterContext;\n    this.precedenceFilterSuppressed = config.precedenceFilterSuppressed;\n    return this;\n}\n\nATNConfig.prototype.checkContext = function(params, config) {\n\tif((params.context===null || params.context===undefined) &&\n\t\t\t(config===null || config.context===null || config.context===undefined)) {\n\t\tthis.context = null;\n\t}\n};\n\n// An ATN configuration is equal to another if both have\n//  the same state, they predict the same alternative, and\n//  syntactic/semantic contexts are the same.\n///\nATNConfig.prototype.equals = function(other) {\n    if (this === other) {\n        return true;\n    } else if (! (other instanceof ATNConfig)) {\n        return false;\n    } else {\n        return this.state.stateNumber===other.state.stateNumber &&\n            this.alt===other.alt &&\n            (this.context===null ? other.context===null : this.context.equals(other.context)) &&\n            this.semanticContext.equals(other.semanticContext) &&\n            this.precedenceFilterSuppressed===other.precedenceFilterSuppressed;\n    }\n};\n\nATNConfig.prototype.shortHashString = function() {\n    return \"\" + this.state.stateNumber + \"/\" + this.alt + \"/\" + this.semanticContext;\n};\n\nATNConfig.prototype.hashString = function() {\n    return \"\" + this.state.stateNumber + \"/\" + this.alt + \"/\" +\n             (this.context===null ? \"\" : this.context.hashString()) +\n             \"/\" + this.semanticContext.hashString();\n};\n\nATNConfig.prototype.toString = function() {\n    return \"(\" + this.state + \",\" + this.alt +\n        (this.context!==null ? \",[\" + this.context.toString() + \"]\" : \"\") +\n        (this.semanticContext !== SemanticContext.NONE ?\n                (\",\" + this.semanticContext.toString())\n                : \"\") +\n        (this.reachesIntoOuterContext>0 ?\n                (\",up=\" + this.reachesIntoOuterContext)\n                : \"\") + \")\";\n};\n\n\nfunction LexerATNConfig(params, config) {\n\tATNConfig.call(this, params, config);\n    \n    // This is the backing field for {@link //getLexerActionExecutor}.\n\tvar lexerActionExecutor = params.lexerActionExecutor || null;\n    this.lexerActionExecutor = lexerActionExecutor || (config!==null ? config.lexerActionExecutor : null);\n    this.passedThroughNonGreedyDecision = config!==null ? this.checkNonGreedyDecision(config, this.state) : false;\n    return this;\n}\n\nLexerATNConfig.prototype = Object.create(ATNConfig.prototype);\nLexerATNConfig.prototype.constructor = LexerATNConfig;\n\nLexerATNConfig.prototype.hashString = function() {\n    return \"\" + this.state.stateNumber + this.alt + this.context +\n            this.semanticContext + (this.passedThroughNonGreedyDecision ? 1 : 0) +\n            this.lexerActionExecutor;\n};\n\nLexerATNConfig.prototype.equals = function(other) {\n    if (this === other) {\n        return true;\n    } else if (!(other instanceof LexerATNConfig)) {\n        return false;\n    } else if (this.passedThroughNonGreedyDecision !== other.passedThroughNonGreedyDecision) {\n        return false;\n    } else if (this.lexerActionExecutor ?\n            !this.lexerActionExecutor.equals(other.lexerActionExecutor)\n            : !other.lexerActionExecutor) {\n        return false;\n    } else {\n        return ATNConfig.prototype.equals.call(this, other);\n    }\n};\n\nLexerATNConfig.prototype.checkNonGreedyDecision = function(source, target) {\n    return source.passedThroughNonGreedyDecision ||\n        (target instanceof DecisionState) && target.nonGreedy;\n};\n\nexports.ATNConfig = ATNConfig;\nexports.LexerATNConfig = LexerATNConfig;\n},{\"./ATNState\":22,\"./SemanticContext\":29}],18:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n//\n// Specialized {@link Set}{@code <}{@link ATNConfig}{@code >} that can track\n// info about the set, with support for combining similar configurations using a\n// graph-structured stack.\n///\n\nvar ATN = require('./ATN').ATN;\nvar Utils = require('./../Utils');\nvar Set = Utils.Set;\nvar SemanticContext = require('./SemanticContext').SemanticContext;\nvar merge = require('./../PredictionContext').merge;\n\nfunction hashATNConfig(c) {\n\treturn c.shortHashString();\n}\n\nfunction equalATNConfigs(a, b) {\n\tif ( a===b ) {\n\t\treturn true;\n\t}\n\tif ( a===null || b===null ) {\n\t\treturn false;\n\t}\n\treturn a.state.stateNumber===b.state.stateNumber &&\n\t\ta.alt===b.alt && a.semanticContext.equals(b.semanticContext);\n}\n\n\nfunction ATNConfigSet(fullCtx) {\n\t//\n\t// The reason that we need this is because we don't want the hash map to use\n\t// the standard hash code and equals. We need all configurations with the\n\t// same\n\t// {@code (s,i,_,semctx)} to be equal. Unfortunately, this key effectively\n\t// doubles\n\t// the number of objects associated with ATNConfigs. The other solution is\n\t// to\n\t// use a hash table that lets us specify the equals/hashcode operation.\n\t// All configs but hashed by (s, i, _, pi) not including context. Wiped out\n\t// when we go readonly as this set becomes a DFA state.\n\tthis.configLookup = new Set(hashATNConfig, equalATNConfigs);\n\t// Indicates that this configuration set is part of a full context\n\t// LL prediction. It will be used to determine how to merge $. With SLL\n\t// it's a wildcard whereas it is not for LL context merge.\n\tthis.fullCtx = fullCtx === undefined ? true : fullCtx;\n\t// Indicates that the set of configurations is read-only. Do not\n\t// allow any code to manipulate the set; DFA states will point at\n\t// the sets and they must not change. This does not protect the other\n\t// fields; in particular, conflictingAlts is set after\n\t// we've made this readonly.\n\tthis.readOnly = false;\n\t// Track the elements as they are added to the set; supports get(i)///\n\tthis.configs = [];\n\n\t// TODO: these fields make me pretty uncomfortable but nice to pack up info\n\t// together, saves recomputation\n\t// TODO: can we track conflicts as they are added to save scanning configs\n\t// later?\n\tthis.uniqueAlt = 0;\n\tthis.conflictingAlts = null;\n\n\t// Used in parser and lexer. In lexer, it indicates we hit a pred\n\t// while computing a closure operation. Don't make a DFA state from this.\n\tthis.hasSemanticContext = false;\n\tthis.dipsIntoOuterContext = false;\n\n\tthis.cachedHashString = \"-1\";\n\n\treturn this;\n}\n\n// Adding a new config means merging contexts with existing configs for\n// {@code (s, i, pi, _)}, where {@code s} is the\n// {@link ATNConfig//state}, {@code i} is the {@link ATNConfig//alt}, and\n// {@code pi} is the {@link ATNConfig//semanticContext}. We use\n// {@code (s,i,pi)} as key.\n//\n// <p>This method updates {@link //dipsIntoOuterContext} and\n// {@link //hasSemanticContext} when necessary.</p>\n// /\nATNConfigSet.prototype.add = function(config, mergeCache) {\n\tif (mergeCache === undefined) {\n\t\tmergeCache = null;\n\t}\n\tif (this.readOnly) {\n\t\tthrow \"This set is readonly\";\n\t}\n\tif (config.semanticContext !== SemanticContext.NONE) {\n\t\tthis.hasSemanticContext = true;\n\t}\n\tif (config.reachesIntoOuterContext > 0) {\n\t\tthis.dipsIntoOuterContext = true;\n\t}\n\tvar existing = this.configLookup.add(config);\n\tif (existing === config) {\n\t\tthis.cachedHashString = \"-1\";\n\t\tthis.configs.push(config); // track order here\n\t\treturn true;\n\t}\n\t// a previous (s,i,pi,_), merge with it and save result\n\tvar rootIsWildcard = !this.fullCtx;\n\tvar merged = merge(existing.context, config.context, rootIsWildcard, mergeCache);\n\t// no need to check for existing.context, config.context in cache\n\t// since only way to create new graphs is \"call rule\" and here. We\n\t// cache at both places.\n\texisting.reachesIntoOuterContext = Math.max( existing.reachesIntoOuterContext, config.reachesIntoOuterContext);\n\t// make sure to preserve the precedence filter suppression during the merge\n\tif (config.precedenceFilterSuppressed) {\n\t\texisting.precedenceFilterSuppressed = true;\n\t}\n\texisting.context = merged; // replace context; no need to alt mapping\n\treturn true;\n};\n\nATNConfigSet.prototype.getStates = function() {\n\tvar states = new Set();\n\tfor (var i = 0; i < this.configs.length; i++) {\n\t\tstates.add(this.configs[i].state);\n\t}\n\treturn states;\n};\n\nATNConfigSet.prototype.getPredicates = function() {\n\tvar preds = [];\n\tfor (var i = 0; i < this.configs.length; i++) {\n\t\tvar c = this.configs[i].semanticContext;\n\t\tif (c !== SemanticContext.NONE) {\n\t\t\tpreds.push(c.semanticContext);\n\t\t}\n\t}\n\treturn preds;\n};\n\nObject.defineProperty(ATNConfigSet.prototype, \"items\", {\n\tget : function() {\n\t\treturn this.configs;\n\t}\n});\n\nATNConfigSet.prototype.optimizeConfigs = function(interpreter) {\n\tif (this.readOnly) {\n\t\tthrow \"This set is readonly\";\n\t}\n\tif (this.configLookup.length === 0) {\n\t\treturn;\n\t}\n\tfor (var i = 0; i < this.configs.length; i++) {\n\t\tvar config = this.configs[i];\n\t\tconfig.context = interpreter.getCachedContext(config.context);\n\t}\n};\n\nATNConfigSet.prototype.addAll = function(coll) {\n\tfor (var i = 0; i < coll.length; i++) {\n\t\tthis.add(coll[i]);\n\t}\n\treturn false;\n};\n\nATNConfigSet.prototype.equals = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof ATNConfigSet)) {\n\t\treturn false;\n\t}\n\treturn this.configs !== null && this.configs.equals(other.configs) &&\n\t\t\tthis.fullCtx === other.fullCtx &&\n\t\t\tthis.uniqueAlt === other.uniqueAlt &&\n\t\t\tthis.conflictingAlts === other.conflictingAlts &&\n\t\t\tthis.hasSemanticContext === other.hasSemanticContext &&\n\t\t\tthis.dipsIntoOuterContext === other.dipsIntoOuterContext;\n};\n\nATNConfigSet.prototype.hashString = function() {\n\tif (this.readOnly) {\n\t\tif (this.cachedHashString === \"-1\") {\n\t\t\tthis.cachedHashString = this.hashConfigs();\n\t\t}\n\t\treturn this.cachedHashString;\n\t} else {\n\t\treturn this.hashConfigs();\n\t}\n};\n\nATNConfigSet.prototype.hashConfigs = function() {\n\tvar s = \"\";\n\tthis.configs.map(function(c) {\n\t\ts += c.toString();\n\t});\n\treturn s;\n};\n\nObject.defineProperty(ATNConfigSet.prototype, \"length\", {\n\tget : function() {\n\t\treturn this.configs.length;\n\t}\n});\n\nATNConfigSet.prototype.isEmpty = function() {\n\treturn this.configs.length === 0;\n};\n\nATNConfigSet.prototype.contains = function(item) {\n\tif (this.configLookup === null) {\n\t\tthrow \"This method is not implemented for readonly sets.\";\n\t}\n\treturn this.configLookup.contains(item);\n};\n\nATNConfigSet.prototype.containsFast = function(item) {\n\tif (this.configLookup === null) {\n\t\tthrow \"This method is not implemented for readonly sets.\";\n\t}\n\treturn this.configLookup.containsFast(item);\n};\n\nATNConfigSet.prototype.clear = function() {\n\tif (this.readOnly) {\n\t\tthrow \"This set is readonly\";\n\t}\n\tthis.configs = [];\n\tthis.cachedHashString = \"-1\";\n\tthis.configLookup = new Set();\n};\n\nATNConfigSet.prototype.setReadonly = function(readOnly) {\n\tthis.readOnly = readOnly;\n\tif (readOnly) {\n\t\tthis.configLookup = null; // can't mod, no need for lookup cache\n\t}\n};\n\nATNConfigSet.prototype.toString = function() {\n\treturn Utils.arrayToString(this.configs) +\n\t\t(this.hasSemanticContext ? \",hasSemanticContext=\" + this.hasSemanticContext : \"\") +\n\t\t(this.uniqueAlt !== ATN.INVALID_ALT_NUMBER ? \",uniqueAlt=\" + this.uniqueAlt : \"\") +\n\t\t(this.conflictingAlts !== null ? \",conflictingAlts=\" + this.conflictingAlts : \"\") +\n\t\t(this.dipsIntoOuterContext ? \",dipsIntoOuterContext\" : \"\");\n};\n\nfunction OrderedATNConfigSet() {\n\tATNConfigSet.call(this);\n\tthis.configLookup = new Set();\n\treturn this;\n}\n\nOrderedATNConfigSet.prototype = Object.create(ATNConfigSet.prototype);\nOrderedATNConfigSet.prototype.constructor = OrderedATNConfigSet;\n\nexports.ATNConfigSet = ATNConfigSet;\nexports.OrderedATNConfigSet = OrderedATNConfigSet;\n\n},{\"./../PredictionContext\":11,\"./../Utils\":15,\"./ATN\":16,\"./SemanticContext\":29}],19:[function(require,module,exports){\n//[The \"BSD license\"]\n// Copyright (c) 2013 Terence Parr\n// Copyright (c) 2013 Sam Harwell\n// Copyright (c) 2014 Eric Vergnaud\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions\n// are met:\n//\n// 1. Redistributions of source code must retain the above copyright\n//    notice, this list of conditions and the following disclaimer.\n// 2. Redistributions in binary form must reproduce the above copyright\n//    notice, this list of conditions and the following disclaimer in the\n//    documentation and/or other materials provided with the distribution.\n// 3. The name of the author may not be used to endorse or promote products\n//    derived from this software without specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nfunction ATNDeserializationOptions(copyFrom) {\n\tif(copyFrom===undefined) {\n\t\tcopyFrom = null;\n\t}\n\tthis.readOnly = false;\n    this.verifyATN = copyFrom===null ? true : copyFrom.verifyATN;\n    this.generateRuleBypassTransitions = copyFrom===null ? false : copyFrom.generateRuleBypassTransitions;\n\n    return this;\n}\n\nATNDeserializationOptions.defaultOptions = new ATNDeserializationOptions();\nATNDeserializationOptions.defaultOptions.readOnly = true;\n\n//    def __setattr__(self, key, value):\n//        if key!=\"readOnly\" and self.readOnly:\n//            raise Exception(\"The object is read only.\")\n//        super(type(self), self).__setattr__(key,value)\n\nexports.ATNDeserializationOptions = ATNDeserializationOptions;\n\n},{}],20:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2013 Terence Parr\n//  Copyright (c) 2013 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nvar Token = require('./../Token').Token;\nvar ATN = require('./ATN').ATN;\nvar ATNType = require('./ATNType').ATNType;\nvar ATNStates = require('./ATNState');\nvar ATNState = ATNStates.ATNState;\nvar BasicState = ATNStates.BasicState;\nvar DecisionState = ATNStates.DecisionState;\nvar BlockStartState = ATNStates.BlockStartState;\nvar BlockEndState = ATNStates.BlockEndState;\nvar LoopEndState = ATNStates.LoopEndState;\nvar RuleStartState = ATNStates.RuleStartState;\nvar RuleStopState = ATNStates.RuleStopState;\nvar TokensStartState = ATNStates.TokensStartState;\nvar PlusLoopbackState = ATNStates.PlusLoopbackState;\nvar StarLoopbackState = ATNStates.StarLoopbackState;\nvar StarLoopEntryState = ATNStates.StarLoopEntryState;\nvar PlusBlockStartState = ATNStates.PlusBlockStartState;\nvar StarBlockStartState = ATNStates.StarBlockStartState;\nvar BasicBlockStartState = ATNStates.BasicBlockStartState;\nvar Transitions = require('./Transition');\nvar Transition = Transitions.Transition;\nvar AtomTransition = Transitions.AtomTransition;\nvar SetTransition = Transitions.SetTransition;\nvar NotSetTransition = Transitions.NotSetTransition;\nvar RuleTransition = Transitions.RuleTransition;\nvar RangeTransition = Transitions.RangeTransition;\nvar ActionTransition = Transitions.ActionTransition;\nvar EpsilonTransition = Transitions.EpsilonTransition;\nvar WildcardTransition = Transitions.WildcardTransition;\nvar PredicateTransition = Transitions.PredicateTransition;\nvar PrecedencePredicateTransition = Transitions.PrecedencePredicateTransition;\nvar IntervalSet = require('./../IntervalSet').IntervalSet;\nvar Interval = require('./../IntervalSet').Interval;\nvar ATNDeserializationOptions = require('./ATNDeserializationOptions').ATNDeserializationOptions;\nvar LexerActions = require('./LexerAction');\nvar LexerActionType = LexerActions.LexerActionType;\nvar LexerSkipAction = LexerActions.LexerSkipAction;\nvar LexerChannelAction = LexerActions.LexerChannelAction;\nvar LexerCustomAction = LexerActions.LexerCustomAction;\nvar LexerMoreAction = LexerActions.LexerMoreAction;\nvar LexerTypeAction = LexerActions.LexerTypeAction;\nvar LexerPushModeAction = LexerActions.LexerPushModeAction;\nvar LexerPopModeAction = LexerActions.LexerPopModeAction;\nvar LexerModeAction = LexerActions.LexerModeAction;\n// This is the earliest supported serialized UUID.\n// stick to serialized version for now, we don't need a UUID instance\nvar BASE_SERIALIZED_UUID = \"AADB8D7E-AEEF-4415-AD2B-8204D6CF042E\";\n\n// This list contains all of the currently supported UUIDs, ordered by when\n// the feature first appeared in this branch.\nvar SUPPORTED_UUIDS = [ BASE_SERIALIZED_UUID ];\n\nvar SERIALIZED_VERSION = 3;\n\n// This is the current serialized UUID.\nvar SERIALIZED_UUID = BASE_SERIALIZED_UUID;\n\nfunction initArray( length, value) {\n\tvar tmp = [];\n\ttmp[length-1] = value;\n\treturn tmp.map(function(i) {return value;});\n}\n\nfunction ATNDeserializer (options) {\n\t\n    if ( options=== undefined || options === null ) {\n        options = ATNDeserializationOptions.defaultOptions;\n    }\n    this.deserializationOptions = options;\n    this.stateFactories = null;\n    this.actionFactories = null;\n    \n    return this;\n}\n\n// Determines if a particular serialized representation of an ATN supports\n// a particular feature, identified by the {@link UUID} used for serializing\n// the ATN at the time the feature was first introduced.\n//\n// @param feature The {@link UUID} marking the first time the feature was\n// supported in the serialized ATN.\n// @param actualUuid The {@link UUID} of the actual serialized ATN which is\n// currently being deserialized.\n// @return {@code true} if the {@code actualUuid} value represents a\n// serialized ATN at or after the feature identified by {@code feature} was\n// introduced; otherwise, {@code false}.\n\nATNDeserializer.prototype.isFeatureSupported = function(feature, actualUuid) {\n    var idx1 = SUPPORTED_UUIDS.index(feature);\n    if (idx1<0) {\n        return false;\n    }\n    var idx2 = SUPPORTED_UUIDS.index(actualUuid);\n    return idx2 >= idx1;\n};\n\nATNDeserializer.prototype.deserialize = function(data) {\n    this.reset(data);\n    this.checkVersion();\n    this.checkUUID();\n    var atn = this.readATN();\n    this.readStates(atn);\n    this.readRules(atn);\n    this.readModes(atn);\n    var sets = this.readSets(atn);\n    this.readEdges(atn, sets);\n    this.readDecisions(atn);\n    this.readLexerActions(atn);\n    this.markPrecedenceDecisions(atn);\n    this.verifyATN(atn);\n    if (this.deserializationOptions.generateRuleBypassTransitions && atn.grammarType === ATNType.PARSER ) {\n        this.generateRuleBypassTransitions(atn);\n        // re-verify after modification\n        this.verifyATN(atn);\n    }\n    return atn;\n};\n\nATNDeserializer.prototype.reset = function(data) {\n\tvar adjust = function(c) {\n        var v = c.charCodeAt(0);\n        return v>1  ? v-2 : -1;\n\t};\n    var temp = data.split(\"\").map(adjust);\n    // don't adjust the first value since that's the version number\n    temp[0] = data.charCodeAt(0);\n    this.data = temp;\n    this.pos = 0;\n};\n\nATNDeserializer.prototype.checkVersion = function() {\n    var version = this.readInt();\n    if ( version !== SERIALIZED_VERSION ) {\n        throw (\"Could not deserialize ATN with version \" + version + \" (expected \" + SERIALIZED_VERSION + \").\");\n    }\n};\n\nATNDeserializer.prototype.checkUUID = function() {\n    var uuid = this.readUUID();\n    if (SUPPORTED_UUIDS.indexOf(uuid)<0) {\n        throw (\"Could not deserialize ATN with UUID: \" + uuid +\n                        \" (expected \" + SERIALIZED_UUID + \" or a legacy UUID).\", uuid, SERIALIZED_UUID);\n    }\n    this.uuid = uuid;\n};\n\nATNDeserializer.prototype.readATN = function() {\n    var grammarType = this.readInt();\n    var maxTokenType = this.readInt();\n    return new ATN(grammarType, maxTokenType);\n};\n\nATNDeserializer.prototype.readStates = function(atn) {\n\tvar j, pair, stateNumber;\n    var loopBackStateNumbers = [];\n    var endStateNumbers = [];\n    var nstates = this.readInt();\n    for(var i=0; i<nstates; i++) {\n        var stype = this.readInt();\n        // ignore bad type of states\n        if (stype===ATNState.INVALID_TYPE) {\n            atn.addState(null);\n            continue;\n        }\n        var ruleIndex = this.readInt();\n        if (ruleIndex === 0xFFFF) {\n            ruleIndex = -1;\n        }\n        var s = this.stateFactory(stype, ruleIndex);\n        if (stype === ATNState.LOOP_END) { // special case\n            var loopBackStateNumber = this.readInt();\n            loopBackStateNumbers.push([s, loopBackStateNumber]);\n        } else if(s instanceof BlockStartState) {\n            var endStateNumber = this.readInt();\n            endStateNumbers.push([s, endStateNumber]);\n        }\n        atn.addState(s);\n    }\n    // delay the assignment of loop back and end states until we know all the\n\t// state instances have been initialized\n    for (j=0; j<loopBackStateNumbers.length; j++) {\n        pair = loopBackStateNumbers[j];\n        pair[0].loopBackState = atn.states[pair[1]];\n    }\n\n    for (j=0; j<endStateNumbers.length; j++) {\n        pair = endStateNumbers[j];\n        pair[0].endState = atn.states[pair[1]];\n    }\n    \n    var numNonGreedyStates = this.readInt();\n    for (j=0; j<numNonGreedyStates; j++) {\n        stateNumber = this.readInt();\n        atn.states[stateNumber].nonGreedy = true;\n    }\n\n    var numPrecedenceStates = this.readInt();\n    for (j=0; j<numPrecedenceStates; j++) {\n        stateNumber = this.readInt();\n        atn.states[stateNumber].isPrecedenceRule = true;\n    }\n};\n\nATNDeserializer.prototype.readRules = function(atn) {\n    var i;\n    var nrules = this.readInt();\n    if (atn.grammarType === ATNType.LEXER ) {\n        atn.ruleToTokenType = initArray(nrules, 0);\n    }\n    atn.ruleToStartState = initArray(nrules, 0);\n    for (i=0; i<nrules; i++) {\n        var s = this.readInt();\n        var startState = atn.states[s];\n        atn.ruleToStartState[i] = startState;\n        if ( atn.grammarType === ATNType.LEXER ) {\n            var tokenType = this.readInt();\n            if (tokenType === 0xFFFF) {\n                tokenType = Token.EOF;\n            }\n            atn.ruleToTokenType[i] = tokenType;\n        }\n    }\n    atn.ruleToStopState = initArray(nrules, 0);\n    for (i=0; i<atn.states.length; i++) {\n        var state = atn.states[i];\n        if (!(state instanceof RuleStopState)) {\n            continue;\n        }\n        atn.ruleToStopState[state.ruleIndex] = state;\n        atn.ruleToStartState[state.ruleIndex].stopState = state;\n    }\n};\n\nATNDeserializer.prototype.readModes = function(atn) {\n    var nmodes = this.readInt();\n    for (var i=0; i<nmodes; i++) {\n        var s = this.readInt();\n        atn.modeToStartState.push(atn.states[s]);\n    }\n};\n\nATNDeserializer.prototype.readSets = function(atn) {\n    var sets = [];\n    var m = this.readInt();\n    for (var i=0; i<m; i++) {\n        var iset = new IntervalSet();\n        sets.push(iset);\n        var n = this.readInt();\n        var containsEof = this.readInt();\n        if (containsEof!==0) {\n            iset.addOne(-1);\n        }\n        for (var j=0; j<n; j++) {\n            var i1 = this.readInt();\n            var i2 = this.readInt();\n            iset.addRange(i1, i2);\n        }\n    }\n    return sets;\n};\n\nATNDeserializer.prototype.readEdges = function(atn, sets) {\n\tvar i, j, state, trans, target;\n    var nedges = this.readInt();\n    for (i=0; i<nedges; i++) {\n        var src = this.readInt();\n        var trg = this.readInt();\n        var ttype = this.readInt();\n        var arg1 = this.readInt();\n        var arg2 = this.readInt();\n        var arg3 = this.readInt();\n        trans = this.edgeFactory(atn, ttype, src, trg, arg1, arg2, arg3, sets);\n        var srcState = atn.states[src];\n        srcState.addTransition(trans);\n    }\n    // edges for rule stop states can be derived, so they aren't serialized\n    for (i=0; i<atn.states.length; i++) {\n        state = atn.states[i];\n        for (j=0; j<state.transitions.length; j++) {\n            var t = state.transitions[j];\n            if (!(t instanceof RuleTransition)) {\n                continue;\n            }\n\t\t\tvar outermostPrecedenceReturn = -1;\n\t\t\tif (atn.ruleToStartState[t.target.ruleIndex].isPrecedenceRule) {\n\t\t\t\tif (t.precedence === 0) {\n\t\t\t\t\toutermostPrecedenceReturn = t.target.ruleIndex;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ttrans = new EpsilonTransition(t.followState, outermostPrecedenceReturn);\n            atn.ruleToStopState[t.target.ruleIndex].addTransition(trans);\n        }\n    }\n\n    for (i=0; i<atn.states.length; i++) {\n        state = atn.states[i];\n        if (state instanceof BlockStartState) {\n            // we need to know the end state to set its start state\n            if (state.endState === null) {\n                throw (\"IllegalState\");\n            }\n            // block end states can only be associated to a single block start\n\t\t\t// state\n            if ( state.endState.startState !== null) {\n                throw (\"IllegalState\");\n            }\n            state.endState.startState = state;\n        }\n        if (state instanceof PlusLoopbackState) {\n            for (j=0; j<state.transitions.length; j++) {\n                target = state.transitions[j].target;\n                if (target instanceof PlusBlockStartState) {\n                    target.loopBackState = state;\n                }\n            }\n        } else if (state instanceof StarLoopbackState) {\n            for (j=0; j<state.transitions.length; j++) {\n                target = state.transitions[j].target;\n                if (target instanceof StarLoopEntryState) {\n                    target.loopBackState = state;\n                }\n            }\n        }\n    }\n};\n\nATNDeserializer.prototype.readDecisions = function(atn) {\n    var ndecisions = this.readInt();\n    for (var i=0; i<ndecisions; i++) {\n        var s = this.readInt();\n        var decState = atn.states[s];\n        atn.decisionToState.push(decState);\n        decState.decision = i;\n    }\n};\n\nATNDeserializer.prototype.readLexerActions = function(atn) {\n    if (atn.grammarType === ATNType.LEXER) {\n        var count = this.readInt();\n        atn.lexerActions = initArray(count, null);\n        for (var i=0; i<count; i++) {\n            var actionType = this.readInt();\n            var data1 = this.readInt();\n            if (data1 === 0xFFFF) {\n                data1 = -1;\n            }\n            var data2 = this.readInt();\n            if (data2 === 0xFFFF) {\n                data2 = -1;\n            }\n            var lexerAction = this.lexerActionFactory(actionType, data1, data2);\n            atn.lexerActions[i] = lexerAction;\n        }\n    }\n};\n\nATNDeserializer.prototype.generateRuleBypassTransitions = function(atn) {\n\tvar i;\n    var count = atn.ruleToStartState.length;\n    for(i=0; i<count; i++) {\n        atn.ruleToTokenType[i] = atn.maxTokenType + i + 1;\n    }\n    for(i=0; i<count; i++) {\n        this.generateRuleBypassTransition(atn, i);\n    }\n};\n\nATNDeserializer.prototype.generateRuleBypassTransition = function(atn, idx) {\n\tvar i, state;\n    var bypassStart = new BasicBlockStartState();\n    bypassStart.ruleIndex = idx;\n    atn.addState(bypassStart);\n\n    var bypassStop = new BlockEndState();\n    bypassStop.ruleIndex = idx;\n    atn.addState(bypassStop);\n\n    bypassStart.endState = bypassStop;\n    atn.defineDecisionState(bypassStart);\n\n    bypassStop.startState = bypassStart;\n\n    var excludeTransition = null;\n    var endState = null;\n    \n    if (atn.ruleToStartState[idx].isPrecedenceRule) {\n        // wrap from the beginning of the rule to the StarLoopEntryState\n        endState = null;\n        for(i=0; i<atn.states.length; i++) {\n            state = atn.states[i];\n            if (this.stateIsEndStateFor(state, idx)) {\n                endState = state;\n                excludeTransition = state.loopBackState.transitions[0];\n                break;\n            }\n        }\n        if (excludeTransition === null) {\n            throw (\"Couldn't identify final state of the precedence rule prefix section.\");\n        }\n    } else {\n        endState = atn.ruleToStopState[idx];\n    }\n    \n    // all non-excluded transitions that currently target end state need to\n\t// target blockEnd instead\n    for(i=0; i<atn.states.length; i++) {\n        state = atn.states[i];\n        for(var j=0; j<state.transitions.length; j++) {\n            var transition = state.transitions[j];\n            if (transition === excludeTransition) {\n                continue;\n            }\n            if (transition.target === endState) {\n                transition.target = bypassStop;\n            }\n        }\n    }\n\n    // all transitions leaving the rule start state need to leave blockStart\n\t// instead\n    var ruleToStartState = atn.ruleToStartState[idx];\n    var count = ruleToStartState.transitions.length;\n    while ( count > 0) {\n        bypassStart.addTransition(ruleToStartState.transitions[count-1]);\n        ruleToStartState.transitions = ruleToStartState.transitions.slice(-1);\n    }\n    // link the new states\n    atn.ruleToStartState[idx].addTransition(new EpsilonTransition(bypassStart));\n    bypassStop.addTransition(new EpsilonTransition(endState));\n\n    var matchState = new BasicState();\n    atn.addState(matchState);\n    matchState.addTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[idx]));\n    bypassStart.addTransition(new EpsilonTransition(matchState));\n};\n\nATNDeserializer.prototype.stateIsEndStateFor = function(state, idx) {\n    if ( state.ruleIndex !== idx) {\n        return null;\n    }\n    if (!( state instanceof StarLoopEntryState)) {\n        return null;\n    }\n    var maybeLoopEndState = state.transitions[state.transitions.length - 1].target;\n    if (!( maybeLoopEndState instanceof LoopEndState)) {\n        return null;\n    }\n    if (maybeLoopEndState.epsilonOnlyTransitions &&\n        (maybeLoopEndState.transitions[0].target instanceof RuleStopState)) {\n        return state;\n    } else {\n        return null;\n    }\n};\n\n//\n// Analyze the {@link StarLoopEntryState} states in the specified ATN to set\n// the {@link StarLoopEntryState//precedenceRuleDecision} field to the\n// correct value.\n//\n// @param atn The ATN.\n//\nATNDeserializer.prototype.markPrecedenceDecisions = function(atn) {\n\tfor(var i=0; i<atn.states.length; i++) {\n\t\tvar state = atn.states[i];\n\t\tif (!( state instanceof StarLoopEntryState)) {\n            continue;\n        }\n        // We analyze the ATN to determine if this ATN decision state is the\n        // decision for the closure block that determines whether a\n        // precedence rule should continue or complete.\n        //\n        if ( atn.ruleToStartState[state.ruleIndex].isPrecedenceRule) {\n            var maybeLoopEndState = state.transitions[state.transitions.length - 1].target;\n            if (maybeLoopEndState instanceof LoopEndState) {\n                if ( maybeLoopEndState.epsilonOnlyTransitions &&\n                        (maybeLoopEndState.transitions[0].target instanceof RuleStopState)) {\n                    state.precedenceRuleDecision = true;\n                }\n            }\n        }\n\t}\n};\n\nATNDeserializer.prototype.verifyATN = function(atn) {\n    if (!this.deserializationOptions.verifyATN) {\n        return;\n    }\n    // verify assumptions\n\tfor(var i=0; i<atn.states.length; i++) {\n        var state = atn.states[i];\n        if (state === null) {\n            continue;\n        }\n        this.checkCondition(state.epsilonOnlyTransitions || state.transitions.length <= 1);\n        if (state instanceof PlusBlockStartState) {\n            this.checkCondition(state.loopBackState !== null);\n        } else  if (state instanceof StarLoopEntryState) {\n            this.checkCondition(state.loopBackState !== null);\n            this.checkCondition(state.transitions.length === 2);\n            if (state.transitions[0].target instanceof StarBlockStartState) {\n                this.checkCondition(state.transitions[1].target instanceof LoopEndState);\n                this.checkCondition(!state.nonGreedy);\n            } else if (state.transitions[0].target instanceof LoopEndState) {\n                this.checkCondition(state.transitions[1].target instanceof StarBlockStartState);\n                this.checkCondition(state.nonGreedy);\n            } else {\n                throw(\"IllegalState\");\n            }\n        } else if (state instanceof StarLoopbackState) {\n            this.checkCondition(state.transitions.length === 1);\n            this.checkCondition(state.transitions[0].target instanceof StarLoopEntryState);\n        } else if (state instanceof LoopEndState) {\n            this.checkCondition(state.loopBackState !== null);\n        } else if (state instanceof RuleStartState) {\n            this.checkCondition(state.stopState !== null);\n        } else if (state instanceof BlockStartState) {\n            this.checkCondition(state.endState !== null);\n        } else if (state instanceof BlockEndState) {\n            this.checkCondition(state.startState !== null);\n        } else if (state instanceof DecisionState) {\n            this.checkCondition(state.transitions.length <= 1 || state.decision >= 0);\n        } else {\n            this.checkCondition(state.transitions.length <= 1 || (state instanceof RuleStopState));\n        }\n\t}\n};\n\nATNDeserializer.prototype.checkCondition = function(condition, message) {\n    if (!condition) {\n        if (message === undefined || message===null) {\n            message = \"IllegalState\";\n        }\n        throw (message);\n    }\n};\n\nATNDeserializer.prototype.readInt = function() {\n    return this.data[this.pos++];\n};\n\nATNDeserializer.prototype.readInt32 = function() {\n    var low = this.readInt();\n    var high = this.readInt();\n    return low | (high << 16);\n};\n\nATNDeserializer.prototype.readLong = function() {\n    var low = this.readInt32();\n    var high = this.readInt32();\n    return (low & 0x00000000FFFFFFFF) | (high << 32);\n};\n\nfunction createByteToHex() {\n\tvar bth = [];\n\tfor (var i = 0; i < 256; i++) {\n\t\tbth[i] = (i + 0x100).toString(16).substr(1).toUpperCase();\n\t}\n\treturn bth;\n}\n\nvar byteToHex = createByteToHex();\n\t\nATNDeserializer.prototype.readUUID = function() {\n\tvar bb = [];\n\tfor(var i=7;i>=0;i--) {\n\t\tvar int = this.readInt();\n\t\t/* jshint bitwise: false */\n\t\tbb[(2*i)+1] = int & 0xFF;\n\t\tbb[2*i] = (int >> 8) & 0xFF;\n\t}\n    return byteToHex[bb[0]] + byteToHex[bb[1]] +\n    byteToHex[bb[2]] + byteToHex[bb[3]] + '-' +\n    byteToHex[bb[4]] + byteToHex[bb[5]] + '-' +\n    byteToHex[bb[6]] + byteToHex[bb[7]] + '-' +\n    byteToHex[bb[8]] + byteToHex[bb[9]] + '-' +\n    byteToHex[bb[10]] + byteToHex[bb[11]] +\n    byteToHex[bb[12]] + byteToHex[bb[13]] +\n    byteToHex[bb[14]] + byteToHex[bb[15]];\n};\n\nATNDeserializer.prototype.edgeFactory = function(atn, type, src, trg, arg1, arg2, arg3, sets) {\n    var target = atn.states[trg];\n    switch(type) {\n    case Transition.EPSILON:\n        return new EpsilonTransition(target);\n    case Transition.RANGE:\n        return arg3 !== 0 ? new RangeTransition(target, Token.EOF, arg2) : new RangeTransition(target, arg1, arg2);\n    case Transition.RULE:\n        return new RuleTransition(atn.states[arg1], arg2, arg3, target);\n    case Transition.PREDICATE:\n        return new PredicateTransition(target, arg1, arg2, arg3 !== 0);\n    case Transition.PRECEDENCE:\n        return new PrecedencePredicateTransition(target, arg1);\n    case Transition.ATOM:\n        return arg3 !== 0 ? new AtomTransition(target, Token.EOF) : new AtomTransition(target, arg1);\n    case Transition.ACTION:\n        return new ActionTransition(target, arg1, arg2, arg3 !== 0);\n    case Transition.SET:\n        return new SetTransition(target, sets[arg1]);\n    case Transition.NOT_SET:\n        return new NotSetTransition(target, sets[arg1]);\n    case Transition.WILDCARD:\n        return new WildcardTransition(target);\n    default:\n        throw \"The specified transition type: \" + type + \" is not valid.\";\n    }\n};\n\nATNDeserializer.prototype.stateFactory = function(type, ruleIndex) {\n    if (this.stateFactories === null) {\n        var sf = [];\n        sf[ATNState.INVALID_TYPE] = null;\n        sf[ATNState.BASIC] = function() { return new BasicState(); };\n        sf[ATNState.RULE_START] = function() { return new RuleStartState(); };\n        sf[ATNState.BLOCK_START] = function() { return new BasicBlockStartState(); };\n        sf[ATNState.PLUS_BLOCK_START] = function() { return new PlusBlockStartState(); };\n        sf[ATNState.STAR_BLOCK_START] = function() { return new StarBlockStartState(); };\n        sf[ATNState.TOKEN_START] = function() { return new TokensStartState(); };\n        sf[ATNState.RULE_STOP] = function() { return new RuleStopState(); };\n        sf[ATNState.BLOCK_END] = function() { return new BlockEndState(); };\n        sf[ATNState.STAR_LOOP_BACK] = function() { return new StarLoopbackState(); };\n        sf[ATNState.STAR_LOOP_ENTRY] = function() { return new StarLoopEntryState(); };\n        sf[ATNState.PLUS_LOOP_BACK] = function() { return new PlusLoopbackState(); };\n        sf[ATNState.LOOP_END] = function() { return new LoopEndState(); };\n        this.stateFactories = sf;\n    }\n    if (type>this.stateFactories.length || this.stateFactories[type] === null) {\n        throw(\"The specified state type \" + type + \" is not valid.\");\n    } else {\n        var s = this.stateFactories[type]();\n        if (s!==null) {\n            s.ruleIndex = ruleIndex;\n            return s;\n        }\n    }\n};\n\nATNDeserializer.prototype.lexerActionFactory = function(type, data1, data2) {\n    if (this.actionFactories === null) {\n        var af = [];\n        af[LexerActionType.CHANNEL] = function(data1, data2) { return new LexerChannelAction(data1); };\n        af[LexerActionType.CUSTOM] = function(data1, data2) { return new LexerCustomAction(data1, data2); };\n        af[LexerActionType.MODE] = function(data1, data2) { return new LexerModeAction(data1); };\n        af[LexerActionType.MORE] = function(data1, data2) { return LexerMoreAction.INSTANCE; };\n        af[LexerActionType.POP_MODE] = function(data1, data2) { return LexerPopModeAction.INSTANCE; };\n        af[LexerActionType.PUSH_MODE] = function(data1, data2) { return new LexerPushModeAction(data1); };\n        af[LexerActionType.SKIP] = function(data1, data2) { return LexerSkipAction.INSTANCE; };\n        af[LexerActionType.TYPE] = function(data1, data2) { return new LexerTypeAction(data1); };\n        this.actionFactories = af;\n    }\n    if (type>this.actionFactories.length || this.actionFactories[type] === null) {\n        throw(\"The specified lexer action type \" + type + \" is not valid.\");\n    } else {\n        return this.actionFactories[type](data1, data2);\n    }\n};\n   \n\nexports.ATNDeserializer = ATNDeserializer;\n},{\"./../IntervalSet\":6,\"./../Token\":14,\"./ATN\":16,\"./ATNDeserializationOptions\":19,\"./ATNState\":22,\"./ATNType\":23,\"./LexerAction\":25,\"./Transition\":30}],21:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2013 Terence Parr\n//  Copyright (c) 2013 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\nvar DFAState = require('./../dfa/DFAState').DFAState;\nvar ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;\nvar getCachedPredictionContext = require('./../PredictionContext').getCachedPredictionContext;\n\nfunction ATNSimulator(atn, sharedContextCache) {\n\t\n    // The context cache maps all PredictionContext objects that are ==\n    //  to a single cached copy. This cache is shared across all contexts\n    //  in all ATNConfigs in all DFA states.  We rebuild each ATNConfigSet\n    //  to use only cached nodes/graphs in addDFAState(). We don't want to\n    //  fill this during closure() since there are lots of contexts that\n    //  pop up but are not used ever again. It also greatly slows down closure().\n    //\n    //  <p>This cache makes a huge difference in memory and a little bit in speed.\n    //  For the Java grammar on java.*, it dropped the memory requirements\n    //  at the end from 25M to 16M. We don't store any of the full context\n    //  graphs in the DFA because they are limited to local context only,\n    //  but apparently there's a lot of repetition there as well. We optimize\n    //  the config contexts before storing the config set in the DFA states\n    //  by literally rebuilding them with cached subgraphs only.</p>\n    //\n    //  <p>I tried a cache for use during closure operations, that was\n    //  whacked after each adaptivePredict(). It cost a little bit\n    //  more time I think and doesn't save on the overall footprint\n    //  so it's not worth the complexity.</p>\n    ///\n    this.atn = atn;\n    this.sharedContextCache = sharedContextCache;\n    return this;\n}\n\n// Must distinguish between missing edge and edge we know leads nowhere///\nATNSimulator.ERROR = new DFAState(0x7FFFFFFF, new ATNConfigSet());\n\n\nATNSimulator.prototype.getCachedContext = function(context) {\n    if (this.sharedContextCache ===null) {\n        return context;\n    }\n    var visited = {};\n    return getCachedPredictionContext(context, this.sharedContextCache, visited);\n};\n\nexports.ATNSimulator = ATNSimulator;\n\n},{\"./../PredictionContext\":11,\"./../dfa/DFAState\":34,\"./ATNConfigSet\":18}],22:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n// The following images show the relation of states and\n// {@link ATNState//transitions} for various grammar constructs.\n//\n// <ul>\n//\n// <li>Solid edges marked with an &//0949; indicate a required\n// {@link EpsilonTransition}.</li>\n//\n// <li>Dashed edges indicate locations where any transition derived from\n// {@link Transition} might appear.</li>\n//\n// <li>Dashed nodes are place holders for either a sequence of linked\n// {@link BasicState} states or the inclusion of a block representing a nested\n// construct in one of the forms below.</li>\n//\n// <li>Nodes showing multiple outgoing alternatives with a {@code ...} support\n// any number of alternatives (one or more). Nodes without the {@code ...} only\n// support the exact number of alternatives shown in the diagram.</li>\n//\n// </ul>\n//\n// <h2>Basic Blocks</h2>\n//\n// <h3>Rule</h3>\n//\n// <embed src=\"images/Rule.svg\" type=\"image/svg+xml\"/>\n//\n// <h3>Block of 1 or more alternatives</h3>\n//\n// <embed src=\"images/Block.svg\" type=\"image/svg+xml\"/>\n//\n// <h2>Greedy Loops</h2>\n//\n// <h3>Greedy Closure: {@code (...)*}</h3>\n//\n// <embed src=\"images/ClosureGreedy.svg\" type=\"image/svg+xml\"/>\n//\n// <h3>Greedy Positive Closure: {@code (...)+}</h3>\n//\n// <embed src=\"images/PositiveClosureGreedy.svg\" type=\"image/svg+xml\"/>\n//\n// <h3>Greedy Optional: {@code (...)?}</h3>\n//\n// <embed src=\"images/OptionalGreedy.svg\" type=\"image/svg+xml\"/>\n//\n// <h2>Non-Greedy Loops</h2>\n//\n// <h3>Non-Greedy Closure: {@code (...)*?}</h3>\n//\n// <embed src=\"images/ClosureNonGreedy.svg\" type=\"image/svg+xml\"/>\n//\n// <h3>Non-Greedy Positive Closure: {@code (...)+?}</h3>\n//\n// <embed src=\"images/PositiveClosureNonGreedy.svg\" type=\"image/svg+xml\"/>\n//\n// <h3>Non-Greedy Optional: {@code (...)??}</h3>\n//\n// <embed src=\"images/OptionalNonGreedy.svg\" type=\"image/svg+xml\"/>\n//\n\nvar INITIAL_NUM_TRANSITIONS = 4;\n\nfunction ATNState() {\n    // Which ATN are we in?\n    this.atn = null;\n    this.stateNumber = ATNState.INVALID_STATE_NUMBER;\n    this.stateType = null;\n    this.ruleIndex = 0; // at runtime, we don't have Rule objects\n    this.epsilonOnlyTransitions = false;\n    // Track the transitions emanating from this ATN state.\n    this.transitions = [];\n    // Used to cache lookahead during parsing, not used during construction\n    this.nextTokenWithinRule = null;\n    return this;\n}\n\n// constants for serialization\nATNState.INVALID_TYPE = 0;\nATNState.BASIC = 1;\nATNState.RULE_START = 2;\nATNState.BLOCK_START = 3;\nATNState.PLUS_BLOCK_START = 4;\nATNState.STAR_BLOCK_START = 5;\nATNState.TOKEN_START = 6;\nATNState.RULE_STOP = 7;\nATNState.BLOCK_END = 8;\nATNState.STAR_LOOP_BACK = 9;\nATNState.STAR_LOOP_ENTRY = 10;\nATNState.PLUS_LOOP_BACK = 11;\nATNState.LOOP_END = 12;\n\nATNState.serializationNames = [\n            \"INVALID\",\n            \"BASIC\",\n            \"RULE_START\",\n            \"BLOCK_START\",\n            \"PLUS_BLOCK_START\",\n            \"STAR_BLOCK_START\",\n            \"TOKEN_START\",\n            \"RULE_STOP\",\n            \"BLOCK_END\",\n            \"STAR_LOOP_BACK\",\n            \"STAR_LOOP_ENTRY\",\n            \"PLUS_LOOP_BACK\",\n            \"LOOP_END\" ];\n\nATNState.INVALID_STATE_NUMBER = -1;\n\nATNState.prototype.toString = function() {\n\treturn this.stateNumber;\n};\n\nATNState.prototype.equals = function(other) {\n    if (other instanceof ATNState) {\n        return this.stateNumber===other.stateNumber;\n    } else {\n        return false;\n    }\n};\n\nATNState.prototype.isNonGreedyExitState = function() {\n    return false;\n};\n\n\nATNState.prototype.addTransition = function(trans, index) {\n\tif(index===undefined) {\n\t\tindex = -1;\n\t}\n    if (this.transitions.length===0) {\n        this.epsilonOnlyTransitions = trans.isEpsilon;\n    } else if(this.epsilonOnlyTransitions !== trans.isEpsilon) {\n        this.epsilonOnlyTransitions = false;\n    }\n    if (index===-1) {\n        this.transitions.push(trans);\n    } else {\n        this.transitions.splice(index, 1, trans);\n    }\n};\n\nfunction BasicState() {\n\tATNState.call(this);\n    this.stateType = ATNState.BASIC;\n    return this;\n}\n\nBasicState.prototype = Object.create(ATNState.prototype);\nBasicState.prototype.constructor = BasicState;\n\n\nfunction DecisionState() {\n\tATNState.call(this);\n    this.decision = -1;\n    this.nonGreedy = false;\n    return this;\n}\n\nDecisionState.prototype = Object.create(ATNState.prototype);\nDecisionState.prototype.constructor = DecisionState;\n\n\n//  The start of a regular {@code (...)} block.\nfunction BlockStartState() {\n\tDecisionState.call(this);\n\tthis.endState = null;\n\treturn this;\n}\n\nBlockStartState.prototype = Object.create(DecisionState.prototype);\nBlockStartState.prototype.constructor = BlockStartState;\n\n\nfunction BasicBlockStartState() {\n\tBlockStartState.call(this);\n\tthis.stateType = ATNState.BLOCK_START;\n\treturn this;\n}\n\nBasicBlockStartState.prototype = Object.create(BlockStartState.prototype);\nBasicBlockStartState.prototype.constructor = BasicBlockStartState;\n\n\n// Terminal node of a simple {@code (a|b|c)} block.\nfunction BlockEndState() {\n\tATNState.call(this);\n\tthis.stateType = ATNState.BLOCK_END;\n    this.startState = null;\n    return this;\n}\n\nBlockEndState.prototype = Object.create(ATNState.prototype);\nBlockEndState.prototype.constructor = BlockEndState;\n\n\n// The last node in the ATN for a rule, unless that rule is the start symbol.\n//  In that case, there is one transition to EOF. Later, we might encode\n//  references to all calls to this rule to compute FOLLOW sets for\n//  error handling.\n//\nfunction RuleStopState() {\n\tATNState.call(this);\n    this.stateType = ATNState.RULE_STOP;\n    return this;\n}\n\nRuleStopState.prototype = Object.create(ATNState.prototype);\nRuleStopState.prototype.constructor = RuleStopState;\n\nfunction RuleStartState() {\n\tATNState.call(this);\n\tthis.stateType = ATNState.RULE_START;\n\tthis.stopState = null;\n\tthis.isPrecedenceRule = false;\n\treturn this;\n}\n\nRuleStartState.prototype = Object.create(ATNState.prototype);\nRuleStartState.prototype.constructor = RuleStartState;\n\n// Decision state for {@code A+} and {@code (A|B)+}.  It has two transitions:\n//  one to the loop back to start of the block and one to exit.\n//\nfunction PlusLoopbackState() {\n\tDecisionState.call(this);\n\tthis.stateType = ATNState.PLUS_LOOP_BACK;\n\treturn this;\n}\n\nPlusLoopbackState.prototype = Object.create(DecisionState.prototype);\nPlusLoopbackState.prototype.constructor = PlusLoopbackState;\n        \n\n// Start of {@code (A|B|...)+} loop. Technically a decision state, but\n//  we don't use for code generation; somebody might need it, so I'm defining\n//  it for completeness. In reality, the {@link PlusLoopbackState} node is the\n//  real decision-making note for {@code A+}.\n//\nfunction PlusBlockStartState() {\n\tBlockStartState.call(this);\n\tthis.stateType = ATNState.PLUS_BLOCK_START;\n    this.loopBackState = null;\n    return this;\n}\n\nPlusBlockStartState.prototype = Object.create(BlockStartState.prototype);\nPlusBlockStartState.prototype.constructor = PlusBlockStartState;\n\n// The block that begins a closure loop.\nfunction StarBlockStartState() {\n\tBlockStartState.call(this);\n\tthis.stateType = ATNState.STAR_BLOCK_START;\n\treturn this;\n}\n\nStarBlockStartState.prototype = Object.create(BlockStartState.prototype);\nStarBlockStartState.prototype.constructor = StarBlockStartState;\n\n\nfunction StarLoopbackState() {\n\tATNState.call(this);\n\tthis.stateType = ATNState.STAR_LOOP_BACK;\n\treturn this;\n}\n\nStarLoopbackState.prototype = Object.create(ATNState.prototype);\nStarLoopbackState.prototype.constructor = StarLoopbackState;\n\n\nfunction StarLoopEntryState() {\n\tDecisionState.call(this);\n\tthis.stateType = ATNState.STAR_LOOP_ENTRY;\n    this.loopBackState = null;\n    // Indicates whether this state can benefit from a precedence DFA during SLL decision making.\n    this.precedenceRuleDecision = null;\n    return this;\n}\n\nStarLoopEntryState.prototype = Object.create(DecisionState.prototype);\nStarLoopEntryState.prototype.constructor = StarLoopEntryState;\n\n\n// Mark the end of a * or + loop.\nfunction LoopEndState() {\n\tATNState.call(this);\n\tthis.stateType = ATNState.LOOP_END;\n\tthis.loopBackState = null;\n\treturn this;\n}\n\nLoopEndState.prototype = Object.create(ATNState.prototype);\nLoopEndState.prototype.constructor = LoopEndState;\n\n\n// The Tokens rule start state linking to each lexer rule start state */\nfunction TokensStartState() {\n\tDecisionState.call(this);\n\tthis.stateType = ATNState.TOKEN_START;\n\treturn this;\n}\n\nTokensStartState.prototype = Object.create(DecisionState.prototype);\nTokensStartState.prototype.constructor = TokensStartState;\n\nexports.ATNState = ATNState;\nexports.BasicState = BasicState;\nexports.DecisionState = DecisionState;\nexports.BlockStartState = BlockStartState;\nexports.BlockEndState = BlockEndState;\nexports.LoopEndState = LoopEndState;\nexports.RuleStartState = RuleStartState;\nexports.RuleStopState = RuleStopState;\nexports.TokensStartState = TokensStartState;\nexports.PlusLoopbackState = PlusLoopbackState;\nexports.StarLoopbackState = StarLoopbackState;\nexports.StarLoopEntryState = StarLoopEntryState;\nexports.PlusBlockStartState = PlusBlockStartState;\nexports.StarBlockStartState = StarBlockStartState;\nexports.BasicBlockStartState = BasicBlockStartState;\n\n},{}],23:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2013 Terence Parr\n//  Copyright (c) 2013 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n// Represents the type of recognizer an ATN applies to.\n\nfunction ATNType() {\n\t\n}\n\nATNType.LEXER = 0;\nATNType.PARSER = 1;\n\nexports.ATNType = ATNType;\n\n\n},{}],24:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n// When we hit an accept state in either the DFA or the ATN, we\n//  have to notify the character stream to start buffering characters\n//  via {@link IntStream//mark} and record the current state. The current sim state\n//  includes the current index into the input, the current line,\n//  and current character position in that line. Note that the Lexer is\n//  tracking the starting line and characterization of the token. These\n//  variables track the \"state\" of the simulator when it hits an accept state.\n//\n//  <p>We track these variables separately for the DFA and ATN simulation\n//  because the DFA simulation often has to fail over to the ATN\n//  simulation. If the ATN simulation fails, we need the DFA to fall\n//  back to its previously accepted state, if any. If the ATN succeeds,\n//  then the ATN does the accept and the DFA simulator that invoked it\n//  can simply return the predicted token type.</p>\n///\n\nvar Token = require('./../Token').Token;\nvar Lexer = require('./../Lexer').Lexer;\nvar ATN = require('./ATN').ATN;\nvar ATNSimulator = require('./ATNSimulator').ATNSimulator;\nvar DFAState = require('./../dfa/DFAState').DFAState;\nvar ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;\nvar OrderedATNConfigSet = require('./ATNConfigSet').OrderedATNConfigSet;\nvar PredictionContext = require('./../PredictionContext').PredictionContext;\nvar SingletonPredictionContext = require('./../PredictionContext').SingletonPredictionContext;\nvar RuleStopState = require('./ATNState').RuleStopState;\nvar LexerATNConfig = require('./ATNConfig').LexerATNConfig;\nvar Transition = require('./Transition').Transition;\nvar LexerActionExecutor = require('./LexerActionExecutor').LexerActionExecutor;\nvar LexerNoViableAltException = require('./../error/Errors').LexerNoViableAltException;\n\nfunction resetSimState(sim) {\n\tsim.index = -1;\n\tsim.line = 0;\n\tsim.column = -1;\n\tsim.dfaState = null;\n}\n\nfunction SimState() {\n\tresetSimState(this);\n\treturn this;\n}\n\nSimState.prototype.reset = function() {\n\tresetSimState(this);\n};\n\nfunction LexerATNSimulator(recog, atn, decisionToDFA, sharedContextCache) {\n\tATNSimulator.call(this, atn, sharedContextCache);\n\tthis.decisionToDFA = decisionToDFA;\n\tthis.recog = recog;\n\t// The current token's starting index into the character stream.\n\t// Shared across DFA to ATN simulation in case the ATN fails and the\n\t// DFA did not have a previous accept state. In this case, we use the\n\t// ATN-generated exception object.\n\tthis.startIndex = -1;\n\t// line number 1..n within the input///\n\tthis.line = 1;\n\t// The index of the character relative to the beginning of the line\n\t// 0..n-1///\n\tthis.column = 0;\n\tthis.mode = Lexer.DEFAULT_MODE;\n\t// Used during DFA/ATN exec to record the most recent accept configuration\n\t// info\n\tthis.prevAccept = new SimState();\n\t// done\n\treturn this;\n}\n\nLexerATNSimulator.prototype = Object.create(ATNSimulator.prototype);\nLexerATNSimulator.prototype.constructor = LexerATNSimulator;\n\nLexerATNSimulator.debug = false;\nLexerATNSimulator.dfa_debug = false;\n\nLexerATNSimulator.MIN_DFA_EDGE = 0;\nLexerATNSimulator.MAX_DFA_EDGE = 127; // forces unicode to stay in ATN\n\nLexerATNSimulator.match_calls = 0;\n\nLexerATNSimulator.prototype.copyState = function(simulator) {\n\tthis.column = simulator.column;\n\tthis.line = simulator.line;\n\tthis.mode = simulator.mode;\n\tthis.startIndex = simulator.startIndex;\n};\n\nLexerATNSimulator.prototype.match = function(input, mode) {\n\tthis.match_calls += 1;\n\tthis.mode = mode;\n\tvar mark = input.mark();\n\ttry {\n\t\tthis.startIndex = input.index;\n\t\tthis.prevAccept.reset();\n\t\tvar dfa = this.decisionToDFA[mode];\n\t\tif (dfa.s0 === null) {\n\t\t\treturn this.matchATN(input);\n\t\t} else {\n\t\t\treturn this.execATN(input, dfa.s0);\n\t\t}\n\t} finally {\n\t\tinput.release(mark);\n\t}\n};\n\nLexerATNSimulator.prototype.reset = function() {\n\tthis.prevAccept.reset();\n\tthis.startIndex = -1;\n\tthis.line = 1;\n\tthis.column = 0;\n\tthis.mode = Lexer.DEFAULT_MODE;\n};\n\nLexerATNSimulator.prototype.matchATN = function(input) {\n\tvar startState = this.atn.modeToStartState[this.mode];\n\n\tif (this.debug) {\n\t\tconsole.log(\"matchATN mode \" + this.mode + \" start: \" + startState);\n\t}\n\tvar old_mode = this.mode;\n\tvar s0_closure = this.computeStartState(input, startState);\n\tvar suppressEdge = s0_closure.hasSemanticContext;\n\ts0_closure.hasSemanticContext = false;\n\n\tvar next = this.addDFAState(s0_closure);\n\tif (!suppressEdge) {\n\t\tthis.decisionToDFA[this.mode].s0 = next;\n\t}\n\n\tvar predict = this.execATN(input, next);\n\n\tif (this.debug) {\n\t\tconsole.log(\"DFA after matchATN: \" + this.decisionToDFA[old_mode].toLexerString());\n\t}\n\treturn predict;\n};\n\nLexerATNSimulator.prototype.execATN = function(input, ds0) {\n\tif (this.debug) {\n\t\tconsole.log(\"start state closure=\" + ds0.configs);\n\t}\n\tif (ds0.isAcceptState) {\n\t\t// allow zero-length tokens\n\t\tthis.captureSimState(this.prevAccept, input, ds0);\n\t}\n\tvar t = input.LA(1);\n\tvar s = ds0; // s is current/from DFA state\n\n\twhile (true) { // while more work\n\t\tif (this.debug) {\n\t\t\tconsole.log(\"execATN loop starting closure: \" + s.configs);\n\t\t}\n\n\t\t// As we move src->trg, src->trg, we keep track of the previous trg to\n\t\t// avoid looking up the DFA state again, which is expensive.\n\t\t// If the previous target was already part of the DFA, we might\n\t\t// be able to avoid doing a reach operation upon t. If s!=null,\n\t\t// it means that semantic predicates didn't prevent us from\n\t\t// creating a DFA state. Once we know s!=null, we check to see if\n\t\t// the DFA state has an edge already for t. If so, we can just reuse\n\t\t// it's configuration set; there's no point in re-computing it.\n\t\t// This is kind of like doing DFA simulation within the ATN\n\t\t// simulation because DFA simulation is really just a way to avoid\n\t\t// computing reach/closure sets. Technically, once we know that\n\t\t// we have a previously added DFA state, we could jump over to\n\t\t// the DFA simulator. But, that would mean popping back and forth\n\t\t// a lot and making things more complicated algorithmically.\n\t\t// This optimization makes a lot of sense for loops within DFA.\n\t\t// A character will take us back to an existing DFA state\n\t\t// that already has lots of edges out of it. e.g., .* in comments.\n\t\t// print(\"Target for:\" + str(s) + \" and:\" + str(t))\n\t\tvar target = this.getExistingTargetState(s, t);\n\t\t// print(\"Existing:\" + str(target))\n\t\tif (target === null) {\n\t\t\ttarget = this.computeTargetState(input, s, t);\n\t\t\t// print(\"Computed:\" + str(target))\n\t\t}\n\t\tif (target === ATNSimulator.ERROR) {\n\t\t\tbreak;\n\t\t}\n\t\t// If this is a consumable input element, make sure to consume before\n\t\t// capturing the accept state so the input index, line, and char\n\t\t// position accurately reflect the state of the interpreter at the\n\t\t// end of the token.\n\t\tif (t !== Token.EOF) {\n\t\t\tthis.consume(input);\n\t\t}\n\t\tif (target.isAcceptState) {\n\t\t\tthis.captureSimState(this.prevAccept, input, target);\n\t\t\tif (t === Token.EOF) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tt = input.LA(1);\n\t\ts = target; // flip; current DFA target becomes new src/from state\n\t}\n\treturn this.failOrAccept(this.prevAccept, input, s.configs, t);\n};\n\n// Get an existing target state for an edge in the DFA. If the target state\n// for the edge has not yet been computed or is otherwise not available,\n// this method returns {@code null}.\n//\n// @param s The current DFA state\n// @param t The next input symbol\n// @return The existing target DFA state for the given input symbol\n// {@code t}, or {@code null} if the target state for this edge is not\n// already cached\nLexerATNSimulator.prototype.getExistingTargetState = function(s, t) {\n\tif (s.edges === null || t < LexerATNSimulator.MIN_DFA_EDGE || t > LexerATNSimulator.MAX_DFA_EDGE) {\n\t\treturn null;\n\t}\n\n\tvar target = s.edges[t - LexerATNSimulator.MIN_DFA_EDGE];\n\tif(target===undefined) {\n\t\ttarget = null;\n\t}\n\tif (this.debug && target !== null) {\n\t\tconsole.log(\"reuse state \" + s.stateNumber + \" edge to \" + target.stateNumber);\n\t}\n\treturn target;\n};\n\n// Compute a target state for an edge in the DFA, and attempt to add the\n// computed state and corresponding edge to the DFA.\n//\n// @param input The input stream\n// @param s The current DFA state\n// @param t The next input symbol\n//\n// @return The computed target DFA state for the given input symbol\n// {@code t}. If {@code t} does not lead to a valid DFA state, this method\n// returns {@link //ERROR}.\nLexerATNSimulator.prototype.computeTargetState = function(input, s, t) {\n\tvar reach = new OrderedATNConfigSet();\n\t// if we don't find an existing DFA state\n\t// Fill reach starting from closure, following t transitions\n\tthis.getReachableConfigSet(input, s.configs, reach, t);\n\n\tif (reach.items.length === 0) { // we got nowhere on t from s\n\t\tif (!reach.hasSemanticContext) {\n\t\t\t// we got nowhere on t, don't throw out this knowledge; it'd\n\t\t\t// cause a failover from DFA later.\n\t\t\tthis.addDFAEdge(s, t, ATNSimulator.ERROR);\n\t\t}\n\t\t// stop when we can't match any more char\n\t\treturn ATNSimulator.ERROR;\n\t}\n\t// Add an edge from s to target DFA found/created for reach\n\treturn this.addDFAEdge(s, t, null, reach);\n};\n\nLexerATNSimulator.prototype.failOrAccept = function(prevAccept, input, reach, t) {\n\tif (this.prevAccept.dfaState !== null) {\n\t\tvar lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor;\n\t\tthis.accept(input, lexerActionExecutor, this.startIndex,\n\t\t\t\tprevAccept.index, prevAccept.line, prevAccept.column);\n\t\treturn prevAccept.dfaState.prediction;\n\t} else {\n\t\t// if no accept and EOF is first char, return EOF\n\t\tif (t === Token.EOF && input.index === this.startIndex) {\n\t\t\treturn Token.EOF;\n\t\t}\n\t\tthrow new LexerNoViableAltException(this.recog, input, this.startIndex, reach);\n\t}\n};\n\n// Given a starting configuration set, figure out all ATN configurations\n// we can reach upon input {@code t}. Parameter {@code reach} is a return\n// parameter.\nLexerATNSimulator.prototype.getReachableConfigSet = function(input, closure,\n\t\treach, t) {\n\t// this is used to skip processing for configs which have a lower priority\n\t// than a config that already reached an accept state for the same rule\n\tvar skipAlt = ATN.INVALID_ALT_NUMBER;\n\tfor (var i = 0; i < closure.items.length; i++) {\n\t\tvar cfg = closure.items[i];\n\t\tvar currentAltReachedAcceptState = (cfg.alt === skipAlt);\n\t\tif (currentAltReachedAcceptState && cfg.passedThroughNonGreedyDecision) {\n\t\t\tcontinue;\n\t\t}\n\t\tif (this.debug) {\n\t\t\tconsole.log(\"testing %s at %s\\n\", this.getTokenName(t), cfg\n\t\t\t\t\t.toString(this.recog, true));\n\t\t}\n\t\tfor (var j = 0; j < cfg.state.transitions.length; j++) {\n\t\t\tvar trans = cfg.state.transitions[j]; // for each transition\n\t\t\tvar target = this.getReachableTarget(trans, t);\n\t\t\tif (target !== null) {\n\t\t\t\tvar lexerActionExecutor = cfg.lexerActionExecutor;\n\t\t\t\tif (lexerActionExecutor !== null) {\n\t\t\t\t\tlexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - this.startIndex);\n\t\t\t\t}\n\t\t\t\tvar treatEofAsEpsilon = (t === Token.EOF);\n\t\t\t\tvar config = new LexerATNConfig({state:target, lexerActionExecutor:lexerActionExecutor}, cfg);\n\t\t\t\tif (this.closure(input, config, reach,\n\t\t\t\t\t\tcurrentAltReachedAcceptState, true, treatEofAsEpsilon)) {\n\t\t\t\t\t// any remaining configs for this alt have a lower priority\n\t\t\t\t\t// than the one that just reached an accept state.\n\t\t\t\t\tskipAlt = cfg.alt;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\nLexerATNSimulator.prototype.accept = function(input, lexerActionExecutor,\n\t\tstartIndex, index, line, charPos) {\n\tif (this.debug) {\n\t\tconsole.log(\"ACTION %s\\n\", lexerActionExecutor);\n\t}\n\t// seek to after last char in token\n\tinput.seek(index);\n\tthis.line = line;\n\tthis.column = charPos;\n\tif (lexerActionExecutor !== null && this.recog !== null) {\n\t\tlexerActionExecutor.execute(this.recog, input, startIndex);\n\t}\n};\n\nLexerATNSimulator.prototype.getReachableTarget = function(trans, t) {\n\tif (trans.matches(t, 0, 0xFFFE)) {\n\t\treturn trans.target;\n\t} else {\n\t\treturn null;\n\t}\n};\n\nLexerATNSimulator.prototype.computeStartState = function(input, p) {\n\tvar initialContext = PredictionContext.EMPTY;\n\tvar configs = new OrderedATNConfigSet();\n\tfor (var i = 0; i < p.transitions.length; i++) {\n\t\tvar target = p.transitions[i].target;\n        var cfg = new LexerATNConfig({state:target, alt:i+1, context:initialContext}, null);\n\t\tthis.closure(input, cfg, configs, false, false, false);\n\t}\n\treturn configs;\n};\n\n// Since the alternatives within any lexer decision are ordered by\n// preference, this method stops pursuing the closure as soon as an accept\n// state is reached. After the first accept state is reached by depth-first\n// search from {@code config}, all other (potentially reachable) states for\n// this rule would have a lower priority.\n//\n// @return {@code true} if an accept state is reached, otherwise\n// {@code false}.\nLexerATNSimulator.prototype.closure = function(input, config, configs,\n\t\tcurrentAltReachedAcceptState, speculative, treatEofAsEpsilon) {\n\tvar cfg = null;\n\tif (this.debug) {\n\t\tconsole.log(\"closure(\" + config.toString(this.recog, true) + \")\");\n\t}\n\tif (config.state instanceof RuleStopState) {\n\t\tif (this.debug) {\n\t\t\tif (this.recog !== null) {\n\t\t\t\tconsole.log(\"closure at %s rule stop %s\\n\", this.recog.getRuleNames()[config.state.ruleIndex], config);\n\t\t\t} else {\n\t\t\t\tconsole.log(\"closure at rule stop %s\\n\", config);\n\t\t\t}\n\t\t}\n\t\tif (config.context === null || config.context.hasEmptyPath()) {\n\t\t\tif (config.context === null || config.context.isEmpty()) {\n\t\t\t\tconfigs.add(config);\n\t\t\t\treturn true;\n\t\t\t} else {\n\t\t\t\tconfigs.add(new LexerATNConfig({ state:config.state, context:PredictionContext.EMPTY}, config));\n\t\t\t\tcurrentAltReachedAcceptState = true;\n\t\t\t}\n\t\t}\n\t\tif (config.context !== null && !config.context.isEmpty()) {\n\t\t\tfor (var i = 0; i < config.context.length; i++) {\n\t\t\t\tif (config.context.getReturnState(i) !== PredictionContext.EMPTY_RETURN_STATE) {\n\t\t\t\t\tvar newContext = config.context.getParent(i); // \"pop\" return state\n\t\t\t\t\tvar returnState = this.atn.states[config.context.getReturnState(i)];\n\t\t\t\t\tcfg = new LexerATNConfig({ state:returnState, context:newContext }, config);\n\t\t\t\t\tcurrentAltReachedAcceptState = this.closure(input, cfg,\n\t\t\t\t\t\t\tconfigs, currentAltReachedAcceptState, speculative,\n\t\t\t\t\t\t\ttreatEofAsEpsilon);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn currentAltReachedAcceptState;\n\t}\n\t// optimization\n\tif (!config.state.epsilonOnlyTransitions) {\n\t\tif (!currentAltReachedAcceptState || !config.passedThroughNonGreedyDecision) {\n\t\t\tconfigs.add(config);\n\t\t}\n\t}\n\tfor (var j = 0; j < config.state.transitions.length; j++) {\n\t\tvar trans = config.state.transitions[j];\n\t\tcfg = this.getEpsilonTarget(input, config, trans, configs, speculative, treatEofAsEpsilon);\n\t\tif (cfg !== null) {\n\t\t\tcurrentAltReachedAcceptState = this.closure(input, cfg, configs,\n\t\t\t\t\tcurrentAltReachedAcceptState, speculative, treatEofAsEpsilon);\n\t\t}\n\t}\n\treturn currentAltReachedAcceptState;\n};\n\n// side-effect: can alter configs.hasSemanticContext\nLexerATNSimulator.prototype.getEpsilonTarget = function(input, config, trans,\n\t\tconfigs, speculative, treatEofAsEpsilon) {\n\tvar cfg = null;\n\tif (trans.serializationType === Transition.RULE) {\n\t\tvar newContext = SingletonPredictionContext.create(config.context, trans.followState.stateNumber);\n\t\tcfg = new LexerATNConfig( { state:trans.target, context:newContext}, config);\n\t} else if (trans.serializationType === Transition.PRECEDENCE) {\n\t\tthrow \"Precedence predicates are not supported in lexers.\";\n\t} else if (trans.serializationType === Transition.PREDICATE) {\n\t\t// Track traversing semantic predicates. If we traverse,\n\t\t// we cannot add a DFA state for this \"reach\" computation\n\t\t// because the DFA would not test the predicate again in the\n\t\t// future. Rather than creating collections of semantic predicates\n\t\t// like v3 and testing them on prediction, v4 will test them on the\n\t\t// fly all the time using the ATN not the DFA. This is slower but\n\t\t// semantically it's not used that often. One of the key elements to\n\t\t// this predicate mechanism is not adding DFA states that see\n\t\t// predicates immediately afterwards in the ATN. For example,\n\n\t\t// a : ID {p1}? | ID {p2}? ;\n\n\t\t// should create the start state for rule 'a' (to save start state\n\t\t// competition), but should not create target of ID state. The\n\t\t// collection of ATN states the following ID references includes\n\t\t// states reached by traversing predicates. Since this is when we\n\t\t// test them, we cannot cash the DFA state target of ID.\n\n\t\tif (this.debug) {\n\t\t\tconsole.log(\"EVAL rule \" + trans.ruleIndex + \":\" + trans.predIndex);\n\t\t}\n\t\tconfigs.hasSemanticContext = true;\n\t\tif (this.evaluatePredicate(input, trans.ruleIndex, trans.predIndex, speculative)) {\n\t\t\tcfg = new LexerATNConfig({ state:trans.target}, config);\n\t\t}\n\t} else if (trans.serializationType === Transition.ACTION) {\n\t\tif (config.context === null || config.context.hasEmptyPath()) {\n\t\t\t// execute actions anywhere in the start rule for a token.\n\t\t\t//\n\t\t\t// TODO: if the entry rule is invoked recursively, some\n\t\t\t// actions may be executed during the recursive call. The\n\t\t\t// problem can appear when hasEmptyPath() is true but\n\t\t\t// isEmpty() is false. In this case, the config needs to be\n\t\t\t// split into two contexts - one with just the empty path\n\t\t\t// and another with everything but the empty path.\n\t\t\t// Unfortunately, the current algorithm does not allow\n\t\t\t// getEpsilonTarget to return two configurations, so\n\t\t\t// additional modifications are needed before we can support\n\t\t\t// the split operation.\n\t\t\tvar lexerActionExecutor = LexerActionExecutor.append(config.lexerActionExecutor,\n\t\t\t\t\tthis.atn.lexerActions[trans.actionIndex]);\n\t\t\tcfg = new LexerATNConfig({ state:trans.target, lexerActionExecutor:lexerActionExecutor }, config);\n\t\t} else {\n\t\t\t// ignore actions in referenced rules\n\t\t\tcfg = new LexerATNConfig( { state:trans.target}, config);\n\t\t}\n\t} else if (trans.serializationType === Transition.EPSILON) {\n\t\tcfg = new LexerATNConfig({ state:trans.target}, config);\n\t} else if (trans.serializationType === Transition.ATOM ||\n\t\t\t\ttrans.serializationType === Transition.RANGE ||\n\t\t\t\ttrans.serializationType === Transition.SET) {\n\t\tif (treatEofAsEpsilon) {\n\t\t\tif (trans.matches(Token.EOF, 0, 0xFFFF)) {\n\t\t\t\tcfg = new LexerATNConfig( { state:trans.target }, config);\n\t\t\t}\n\t\t}\n\t}\n\treturn cfg;\n};\n\n// Evaluate a predicate specified in the lexer.\n//\n// <p>If {@code speculative} is {@code true}, this method was called before\n// {@link //consume} for the matched character. This method should call\n// {@link //consume} before evaluating the predicate to ensure position\n// sensitive values, including {@link Lexer//getText}, {@link Lexer//getLine},\n// and {@link Lexer//getcolumn}, properly reflect the current\n// lexer state. This method should restore {@code input} and the simulator\n// to the original state before returning (i.e. undo the actions made by the\n// call to {@link //consume}.</p>\n//\n// @param input The input stream.\n// @param ruleIndex The rule containing the predicate.\n// @param predIndex The index of the predicate within the rule.\n// @param speculative {@code true} if the current index in {@code input} is\n// one character before the predicate's location.\n//\n// @return {@code true} if the specified predicate evaluates to\n// {@code true}.\n// /\nLexerATNSimulator.prototype.evaluatePredicate = function(input, ruleIndex,\n\t\tpredIndex, speculative) {\n\t// assume true if no recognizer was provided\n\tif (this.recog === null) {\n\t\treturn true;\n\t}\n\tif (!speculative) {\n\t\treturn this.recog.sempred(null, ruleIndex, predIndex);\n\t}\n\tvar savedcolumn = this.column;\n\tvar savedLine = this.line;\n\tvar index = input.index;\n\tvar marker = input.mark();\n\ttry {\n\t\tthis.consume(input);\n\t\treturn this.recog.sempred(null, ruleIndex, predIndex);\n\t} finally {\n\t\tthis.column = savedcolumn;\n\t\tthis.line = savedLine;\n\t\tinput.seek(index);\n\t\tinput.release(marker);\n\t}\n};\n\nLexerATNSimulator.prototype.captureSimState = function(settings, input, dfaState) {\n\tsettings.index = input.index;\n\tsettings.line = this.line;\n\tsettings.column = this.column;\n\tsettings.dfaState = dfaState;\n};\n\nLexerATNSimulator.prototype.addDFAEdge = function(from_, tk, to, cfgs) {\n\tif (to === undefined) {\n\t\tto = null;\n\t}\n\tif (cfgs === undefined) {\n\t\tcfgs = null;\n\t}\n\tif (to === null && cfgs !== null) {\n\t\t// leading to this call, ATNConfigSet.hasSemanticContext is used as a\n\t\t// marker indicating dynamic predicate evaluation makes this edge\n\t\t// dependent on the specific input sequence, so the static edge in the\n\t\t// DFA should be omitted. The target DFAState is still created since\n\t\t// execATN has the ability to resynchronize with the DFA state cache\n\t\t// following the predicate evaluation step.\n\t\t//\n\t\t// TJP notes: next time through the DFA, we see a pred again and eval.\n\t\t// If that gets us to a previously created (but dangling) DFA\n\t\t// state, we can continue in pure DFA mode from there.\n\t\t// /\n\t\tvar suppressEdge = cfgs.hasSemanticContext;\n\t\tcfgs.hasSemanticContext = false;\n\n\t\tto = this.addDFAState(cfgs);\n\n\t\tif (suppressEdge) {\n\t\t\treturn to;\n\t\t}\n\t}\n\t// add the edge\n\tif (tk < LexerATNSimulator.MIN_DFA_EDGE || tk > LexerATNSimulator.MAX_DFA_EDGE) {\n\t\t// Only track edges within the DFA bounds\n\t\treturn to;\n\t}\n\tif (this.debug) {\n\t\tconsole.log(\"EDGE \" + from_ + \" -> \" + to + \" upon \" + tk);\n\t}\n\tif (from_.edges === null) {\n\t\t// make room for tokens 1..n and -1 masquerading as index 0\n\t\tfrom_.edges = [];\n\t}\n\tfrom_.edges[tk - LexerATNSimulator.MIN_DFA_EDGE] = to; // connect\n\n\treturn to;\n};\n\n// Add a new DFA state if there isn't one with this set of\n// configurations already. This method also detects the first\n// configuration containing an ATN rule stop state. Later, when\n// traversing the DFA, we will know which rule to accept.\nLexerATNSimulator.prototype.addDFAState = function(configs) {\n\tvar proposed = new DFAState(null, configs);\n\tvar firstConfigWithRuleStopState = null;\n\tfor (var i = 0; i < configs.items.length; i++) {\n\t\tvar cfg = configs.items[i];\n\t\tif (cfg.state instanceof RuleStopState) {\n\t\t\tfirstConfigWithRuleStopState = cfg;\n\t\t\tbreak;\n\t\t}\n\t}\n\tif (firstConfigWithRuleStopState !== null) {\n\t\tproposed.isAcceptState = true;\n\t\tproposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor;\n\t\tproposed.prediction = this.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex];\n\t}\n\tvar hash = proposed.hashString();\n\tvar dfa = this.decisionToDFA[this.mode];\n\tvar existing = dfa.states[hash] || null;\n\tif (existing!==null) {\n\t\treturn existing;\n\t}\n\tvar newState = proposed;\n\tnewState.stateNumber = dfa.states.length;\n\tconfigs.setReadonly(true);\n\tnewState.configs = configs;\n\tdfa.states[hash] = newState;\n\treturn newState;\n};\n\nLexerATNSimulator.prototype.getDFA = function(mode) {\n\treturn this.decisionToDFA[mode];\n};\n\n// Get the text matched so far for the current token.\nLexerATNSimulator.prototype.getText = function(input) {\n\t// index is first lookahead char, don't include.\n\treturn input.getText(this.startIndex, input.index - 1);\n};\n\nLexerATNSimulator.prototype.consume = function(input) {\n\tvar curChar = input.LA(1);\n\tif (curChar === \"\\n\".charCodeAt(0)) {\n\t\tthis.line += 1;\n\t\tthis.column = 0;\n\t} else {\n\t\tthis.column += 1;\n\t}\n\tinput.consume();\n};\n\nLexerATNSimulator.prototype.getTokenName = function(tt) {\n\tif (tt === -1) {\n\t\treturn \"EOF\";\n\t} else {\n\t\treturn \"'\" + String.fromCharCode(tt) + \"'\";\n\t}\n};\n\nexports.LexerATNSimulator = LexerATNSimulator;\n\n},{\"./../Lexer\":8,\"./../PredictionContext\":11,\"./../Token\":14,\"./../dfa/DFAState\":34,\"./../error/Errors\":39,\"./ATN\":16,\"./ATNConfig\":17,\"./ATNConfigSet\":18,\"./ATNSimulator\":21,\"./ATNState\":22,\"./LexerActionExecutor\":26,\"./Transition\":30}],25:[function(require,module,exports){\n//\n //[The \"BSD license\"]\n // Copyright (c) 2013 Terence Parr\n // Copyright (c) 2013 Sam Harwell\n // Copyright (c) 2014 Eric Vergnaud\n // All rights reserved.\n //\n // Redistribution and use in source and binary forms, with or without\n // modification, are permitted provided that the following conditions\n // are met:\n //\n // 1. Redistributions of source code must retain the above copyright\n //    notice, this list of conditions and the following disclaimer.\n // 2. Redistributions in binary form must reproduce the above copyright\n //    notice, this list of conditions and the following disclaimer in the\n //    documentation and/or other materials provided with the distribution.\n // 3. The name of the author may not be used to endorse or promote products\n //    derived from this software without specific prior written permission.\n //\n // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n //\n\nfunction LexerActionType() {\n}\n\nLexerActionType.CHANNEL = 0;     //The type of a {@link LexerChannelAction} action.\nLexerActionType.CUSTOM = 1;      //The type of a {@link LexerCustomAction} action.\nLexerActionType.MODE = 2;        //The type of a {@link LexerModeAction} action.\nLexerActionType.MORE = 3;        //The type of a {@link LexerMoreAction} action.\nLexerActionType.POP_MODE = 4;    //The type of a {@link LexerPopModeAction} action.\nLexerActionType.PUSH_MODE = 5;   //The type of a {@link LexerPushModeAction} action.\nLexerActionType.SKIP = 6;        //The type of a {@link LexerSkipAction} action.\nLexerActionType.TYPE = 7;        //The type of a {@link LexerTypeAction} action.\n\nfunction LexerAction(action) {\n    this.actionType = action;\n    this.isPositionDependent = false;\n    return this;\n}\n\nLexerAction.prototype.hashString = function() {\n    return \"\" + this.actionType;\n};\n\nLexerAction.prototype.equals = function(other) {\n    return this === other;\n};\n\n\n\n//\n// Implements the {@code skip} lexer action by calling {@link Lexer//skip}.\n//\n// <p>The {@code skip} command does not have any parameters, so this action is\n// implemented as a singleton instance exposed by {@link //INSTANCE}.</p>\nfunction LexerSkipAction() {\n\tLexerAction.call(this, LexerActionType.SKIP);\n\treturn this;\n}\n\nLexerSkipAction.prototype = Object.create(LexerAction.prototype);\nLexerSkipAction.prototype.constructor = LexerSkipAction;\n\n// Provides a singleton instance of this parameterless lexer action.\nLexerSkipAction.INSTANCE = new LexerSkipAction();\n\nLexerSkipAction.prototype.execute = function(lexer) {\n    lexer.skip();\n};\n\nLexerSkipAction.prototype.toString = function() {\n\treturn \"skip\";\n};\n\n//  Implements the {@code type} lexer action by calling {@link Lexer//setType}\n// with the assigned type.\nfunction LexerTypeAction(type) {\n\tLexerAction.call(this, LexerActionType.TYPE);\n\tthis.type = type;\n\treturn this;\n}\n\nLexerTypeAction.prototype = Object.create(LexerAction.prototype);\nLexerTypeAction.prototype.constructor = LexerTypeAction;\n\nLexerTypeAction.prototype.execute = function(lexer) {\n    lexer.type = this.type;\n};\n\nLexerTypeAction.prototype.hashString = function() {\n\treturn \"\" + this.actionType + this.type;\n};\n\n\nLexerTypeAction.prototype.equals = function(other) {\n    if(this === other) {\n        return true;\n    } else if (! (other instanceof LexerTypeAction)) {\n        return false;\n    } else {\n        return this.type === other.type;\n    }\n};\n\nLexerTypeAction.prototype.toString = function() {\n    return \"type(\" + this.type + \")\";\n};\n\n// Implements the {@code pushMode} lexer action by calling\n// {@link Lexer//pushMode} with the assigned mode.\nfunction LexerPushModeAction(mode) {\n\tLexerAction.call(this, LexerActionType.PUSH_MODE);\n    this.mode = mode;\n    return this;\n}\n\nLexerPushModeAction.prototype = Object.create(LexerAction.prototype);\nLexerPushModeAction.prototype.constructor = LexerPushModeAction;\n\n// <p>This action is implemented by calling {@link Lexer//pushMode} with the\n// value provided by {@link //getMode}.</p>\nLexerPushModeAction.prototype.execute = function(lexer) {\n    lexer.pushMode(this.mode);\n};\n\nLexerPushModeAction.prototype.hashString = function() {\n    return \"\" + this.actionType + this.mode;\n};\n\nLexerPushModeAction.prototype.equals = function(other) {\n    if (this === other) {\n        return true;\n    } else if (! (other instanceof LexerPushModeAction)) {\n        return false;\n    } else {\n        return this.mode === other.mode;\n    }\n};\n\nLexerPushModeAction.prototype.toString = function() {\n\treturn \"pushMode(\" + this.mode + \")\";\n};\n\n\n// Implements the {@code popMode} lexer action by calling {@link Lexer//popMode}.\n//\n// <p>The {@code popMode} command does not have any parameters, so this action is\n// implemented as a singleton instance exposed by {@link //INSTANCE}.</p>\nfunction LexerPopModeAction() {\n\tLexerAction.call(this,LexerActionType.POP_MODE);\n\treturn this;\n}\n\nLexerPopModeAction.prototype = Object.create(LexerAction.prototype);\nLexerPopModeAction.prototype.constructor = LexerPopModeAction;\n\nLexerPopModeAction.INSTANCE = new LexerPopModeAction();\n\n// <p>This action is implemented by calling {@link Lexer//popMode}.</p>\nLexerPopModeAction.prototype.execute = function(lexer) {\n    lexer.popMode();\n};\n\nLexerPopModeAction.prototype.toString = function() {\n\treturn \"popMode\";\n};\n\n// Implements the {@code more} lexer action by calling {@link Lexer//more}.\n//\n// <p>The {@code more} command does not have any parameters, so this action is\n// implemented as a singleton instance exposed by {@link //INSTANCE}.</p>\nfunction LexerMoreAction() {\n\tLexerAction.call(this, LexerActionType.MORE);\n\treturn this;\n}\n\nLexerMoreAction.prototype = Object.create(LexerAction.prototype);\nLexerMoreAction.prototype.constructor = LexerMoreAction;\n\nLexerMoreAction.INSTANCE = new LexerMoreAction();\n\n// <p>This action is implemented by calling {@link Lexer//popMode}.</p>\nLexerMoreAction.prototype.execute = function(lexer) {\n    lexer.more();\n};\n\nLexerMoreAction.prototype.toString = function() {\n    return \"more\";\n};\n\n\n// Implements the {@code mode} lexer action by calling {@link Lexer//mode} with\n// the assigned mode.\nfunction LexerModeAction(mode) {\n\tLexerAction.call(this, LexerActionType.MODE);\n    this.mode = mode;\n    return this;\n}\n\nLexerModeAction.prototype = Object.create(LexerAction.prototype);\nLexerModeAction.prototype.constructor = LexerModeAction;\n\n// <p>This action is implemented by calling {@link Lexer//mode} with the\n// value provided by {@link //getMode}.</p>\nLexerModeAction.prototype.execute = function(lexer) {\n    lexer.mode(this.mode);\n};\n\nLexerModeAction.prototype.hashString = function() {\n\treturn \"\" + this.actionType + this.mode;\n};\n\nLexerModeAction.prototype.equals = function(other) {\n    if (this === other) {\n        return true;\n    } else if (! (other instanceof LexerModeAction)) {\n        return false;\n    } else {\n        return this.mode === other.mode;\n    }\n};\n\nLexerModeAction.prototype.toString = function() {\n    return \"mode(\" + this.mode + \")\";\n};\n\n// Executes a custom lexer action by calling {@link Recognizer//action} with the\n// rule and action indexes assigned to the custom action. The implementation of\n// a custom action is added to the generated code for the lexer in an override\n// of {@link Recognizer//action} when the grammar is compiled.\n//\n// <p>This class may represent embedded actions created with the <code>{...}</code>\n// syntax in ANTLR 4, as well as actions created for lexer commands where the\n// command argument could not be evaluated when the grammar was compiled.</p>\n\n\n    // Constructs a custom lexer action with the specified rule and action\n    // indexes.\n    //\n    // @param ruleIndex The rule index to use for calls to\n    // {@link Recognizer//action}.\n    // @param actionIndex The action index to use for calls to\n    // {@link Recognizer//action}.\n\nfunction LexerCustomAction(ruleIndex, actionIndex) {\n\tLexerAction.call(this, LexerActionType.CUSTOM);\n    this.ruleIndex = ruleIndex;\n    this.actionIndex = actionIndex;\n    this.isPositionDependent = true;\n    return this;\n}\n\nLexerCustomAction.prototype = Object.create(LexerAction.prototype);\nLexerCustomAction.prototype.constructor = LexerCustomAction;\n\n// <p>Custom actions are implemented by calling {@link Lexer//action} with the\n// appropriate rule and action indexes.</p>\nLexerCustomAction.prototype.execute = function(lexer) {\n    lexer.action(null, this.ruleIndex, this.actionIndex);\n};\n\nLexerCustomAction.prototype.hashString = function() {\n    return \"\" + this.actionType + this.ruleIndex + this.actionIndex;\n};\n\nLexerCustomAction.prototype.equals = function(other) {\n    if (this === other) {\n        return true;\n    } else if (! (other instanceof LexerCustomAction)) {\n        return false;\n    } else {\n        return this.ruleIndex === other.ruleIndex && this.actionIndex === other.actionIndex;\n    }\n};\n\n// Implements the {@code channel} lexer action by calling\n// {@link Lexer//setChannel} with the assigned channel.\n// Constructs a new {@code channel} action with the specified channel value.\n// @param channel The channel value to pass to {@link Lexer//setChannel}.\nfunction LexerChannelAction(channel) {\n\tLexerAction.call(this, LexerActionType.CHANNEL);\n    this.channel = channel;\n    return this;\n}\n\nLexerChannelAction.prototype = Object.create(LexerAction.prototype);\nLexerChannelAction.prototype.constructor = LexerChannelAction;\n\n// <p>This action is implemented by calling {@link Lexer//setChannel} with the\n// value provided by {@link //getChannel}.</p>\nLexerChannelAction.prototype.execute = function(lexer) {\n    lexer._channel = this.channel;\n};\n\nLexerChannelAction.prototype.hashString = function() {\n    return \"\" + this.actionType + this.channel;\n};\n\nLexerChannelAction.prototype.equals = function(other) {\n    if (this === other) {\n        return true;\n    } else if (! (other instanceof LexerChannelAction)) {\n        return false;\n    } else {\n        return this.channel === other.channel;\n    }\n};\n\nLexerChannelAction.prototype.toString = function() {\n    return \"channel(\" + this.channel + \")\";\n};\n\n// This implementation of {@link LexerAction} is used for tracking input offsets\n// for position-dependent actions within a {@link LexerActionExecutor}.\n//\n// <p>This action is not serialized as part of the ATN, and is only required for\n// position-dependent lexer actions which appear at a location other than the\n// end of a rule. For more information about DFA optimizations employed for\n// lexer actions, see {@link LexerActionExecutor//append} and\n// {@link LexerActionExecutor//fixOffsetBeforeMatch}.</p>\n\n// Constructs a new indexed custom action by associating a character offset\n// with a {@link LexerAction}.\n//\n// <p>Note: This class is only required for lexer actions for which\n// {@link LexerAction//isPositionDependent} returns {@code true}.</p>\n//\n// @param offset The offset into the input {@link CharStream}, relative to\n// the token start index, at which the specified lexer action should be\n// executed.\n// @param action The lexer action to execute at a particular offset in the\n// input {@link CharStream}.\nfunction LexerIndexedCustomAction(offset, action) {\n\tLexerAction.call(this, action.actionType);\n    this.offset = offset;\n    this.action = action;\n    this.isPositionDependent = true;\n    return this;\n}\n\nLexerIndexedCustomAction.prototype = Object.create(LexerAction.prototype);\nLexerIndexedCustomAction.prototype.constructor = LexerIndexedCustomAction;\n\n// <p>This method calls {@link //execute} on the result of {@link //getAction}\n// using the provided {@code lexer}.</p>\nLexerIndexedCustomAction.prototype.execute = function(lexer) {\n    // assume the input stream position was properly set by the calling code\n    this.action.execute(lexer);\n};\n\nLexerIndexedCustomAction.prototype.hashString = function() {\n    return \"\" + this.actionType + this.offset + this.action;\n};\n\nLexerIndexedCustomAction.prototype.equals = function(other) {\n    if (this === other) {\n        return true;\n    } else if (! (other instanceof LexerIndexedCustomAction)) {\n        return false;\n    } else {\n        return this.offset === other.offset && this.action === other.action;\n    }\n};\n\n\nexports.LexerActionType = LexerActionType;\nexports.LexerSkipAction = LexerSkipAction;\nexports.LexerChannelAction = LexerChannelAction;\nexports.LexerCustomAction = LexerCustomAction;\nexports.LexerIndexedCustomAction = LexerIndexedCustomAction;\nexports.LexerMoreAction = LexerMoreAction;\nexports.LexerTypeAction = LexerTypeAction;\nexports.LexerPushModeAction = LexerPushModeAction;\nexports.LexerPopModeAction = LexerPopModeAction;\nexports.LexerModeAction = LexerModeAction;\n},{}],26:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2013 Terence Parr\n//  Copyright (c) 2013 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n// Represents an executor for a sequence of lexer actions which traversed during\n// the matching operation of a lexer rule (token).\n//\n// <p>The executor tracks position information for position-dependent lexer actions\n// efficiently, ensuring that actions appearing only at the end of the rule do\n// not cause bloating of the {@link DFA} created for the lexer.</p>\n\nvar LexerIndexedCustomAction = require('./LexerAction').LexerIndexedCustomAction;\n\nfunction LexerActionExecutor(lexerActions) {\n\tthis.lexerActions = lexerActions === null ? [] : lexerActions;\n\t// Caches the result of {@link //hashCode} since the hash code is an element\n\t// of the performance-critical {@link LexerATNConfig//hashCode} operation.\n\tthis._hashString = lexerActions.toString(); // \"\".join([str(la) for la in\n\t// lexerActions]))\n\treturn this;\n}\n\n// Creates a {@link LexerActionExecutor} which executes the actions for\n// the input {@code lexerActionExecutor} followed by a specified\n// {@code lexerAction}.\n//\n// @param lexerActionExecutor The executor for actions already traversed by\n// the lexer while matching a token within a particular\n// {@link LexerATNConfig}. If this is {@code null}, the method behaves as\n// though it were an empty executor.\n// @param lexerAction The lexer action to execute after the actions\n// specified in {@code lexerActionExecutor}.\n//\n// @return A {@link LexerActionExecutor} for executing the combine actions\n// of {@code lexerActionExecutor} and {@code lexerAction}.\nLexerActionExecutor.append = function(lexerActionExecutor, lexerAction) {\n\tif (lexerActionExecutor === null) {\n\t\treturn new LexerActionExecutor([ lexerAction ]);\n\t}\n\tvar lexerActions = lexerActionExecutor.lexerActions.concat([ lexerAction ]);\n\treturn new LexerActionExecutor(lexerActions);\n};\n\n// Creates a {@link LexerActionExecutor} which encodes the current offset\n// for position-dependent lexer actions.\n//\n// <p>Normally, when the executor encounters lexer actions where\n// {@link LexerAction//isPositionDependent} returns {@code true}, it calls\n// {@link IntStream//seek} on the input {@link CharStream} to set the input\n// position to the <em>end</em> of the current token. This behavior provides\n// for efficient DFA representation of lexer actions which appear at the end\n// of a lexer rule, even when the lexer rule matches a variable number of\n// characters.</p>\n//\n// <p>Prior to traversing a match transition in the ATN, the current offset\n// from the token start index is assigned to all position-dependent lexer\n// actions which have not already been assigned a fixed offset. By storing\n// the offsets relative to the token start index, the DFA representation of\n// lexer actions which appear in the middle of tokens remains efficient due\n// to sharing among tokens of the same length, regardless of their absolute\n// position in the input stream.</p>\n//\n// <p>If the current executor already has offsets assigned to all\n// position-dependent lexer actions, the method returns {@code this}.</p>\n//\n// @param offset The current offset to assign to all position-dependent\n// lexer actions which do not already have offsets assigned.\n//\n// @return A {@link LexerActionExecutor} which stores input stream offsets\n// for all position-dependent lexer actions.\n// /\nLexerActionExecutor.prototype.fixOffsetBeforeMatch = function(offset) {\n\tvar updatedLexerActions = null;\n\tfor (var i = 0; i < this.lexerActions.length; i++) {\n\t\tif (this.lexerActions[i].isPositionDependent &&\n\t\t\t\t!(this.lexerActions[i] instanceof LexerIndexedCustomAction)) {\n\t\t\tif (updatedLexerActions === null) {\n\t\t\t\tupdatedLexerActions = this.lexerActions.concat([]);\n\t\t\t}\n\t\t\tupdatedLexerActions[i] = new LexerIndexedCustomAction(offset,\n\t\t\t\t\tthis.lexerActions[i]);\n\t\t}\n\t}\n\tif (updatedLexerActions === null) {\n\t\treturn this;\n\t} else {\n\t\treturn new LexerActionExecutor(updatedLexerActions);\n\t}\n};\n\n// Execute the actions encapsulated by this executor within the context of a\n// particular {@link Lexer}.\n//\n// <p>This method calls {@link IntStream//seek} to set the position of the\n// {@code input} {@link CharStream} prior to calling\n// {@link LexerAction//execute} on a position-dependent action. Before the\n// method returns, the input position will be restored to the same position\n// it was in when the method was invoked.</p>\n//\n// @param lexer The lexer instance.\n// @param input The input stream which is the source for the current token.\n// When this method is called, the current {@link IntStream//index} for\n// {@code input} should be the start of the following token, i.e. 1\n// character past the end of the current token.\n// @param startIndex The token start index. This value may be passed to\n// {@link IntStream//seek} to set the {@code input} position to the beginning\n// of the token.\n// /\nLexerActionExecutor.prototype.execute = function(lexer, input, startIndex) {\n\tvar requiresSeek = false;\n\tvar stopIndex = input.index;\n\ttry {\n\t\tfor (var i = 0; i < this.lexerActions.length; i++) {\n\t\t\tvar lexerAction = this.lexerActions[i];\n\t\t\tif (lexerAction instanceof LexerIndexedCustomAction) {\n\t\t\t\tvar offset = lexerAction.offset;\n\t\t\t\tinput.seek(startIndex + offset);\n\t\t\t\tlexerAction = lexerAction.action;\n\t\t\t\trequiresSeek = (startIndex + offset) !== stopIndex;\n\t\t\t} else if (lexerAction.isPositionDependent) {\n\t\t\t\tinput.seek(stopIndex);\n\t\t\t\trequiresSeek = false;\n\t\t\t}\n\t\t\tlexerAction.execute(lexer);\n\t\t}\n\t} finally {\n\t\tif (requiresSeek) {\n\t\t\tinput.seek(stopIndex);\n\t\t}\n\t}\n};\n\nLexerActionExecutor.prototype.hashString = function() {\n\treturn this._hashString;\n};\n\nLexerActionExecutor.prototype.equals = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof LexerActionExecutor)) {\n\t\treturn false;\n\t} else if (this._hashString != other._hashString) {\n\t\treturn false;\n\t} else if (this.lexerActions.length != other.lexerActions.length) {\n\t\treturn false;\n\t} else {\n\t\tvar numActions = this.lexerActions.length\n\t\tfor (var idx = 0; idx < numActions; ++idx) {\n\t\t\tif (!this.lexerActions[idx].equals(other.lexerActions[idx])) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n};\n\nexports.LexerActionExecutor = LexerActionExecutor;\n\n},{\"./LexerAction\":25}],27:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n//\n// The embodiment of the adaptive LL(*), ALL(*), parsing strategy.\n//\n// <p>\n// The basic complexity of the adaptive strategy makes it harder to understand.\n// We begin with ATN simulation to build paths in a DFA. Subsequent prediction\n// requests go through the DFA first. If they reach a state without an edge for\n// the current symbol, the algorithm fails over to the ATN simulation to\n// complete the DFA path for the current input (until it finds a conflict state\n// or uniquely predicting state).</p>\n//\n// <p>\n// All of that is done without using the outer context because we want to create\n// a DFA that is not dependent upon the rule invocation stack when we do a\n// prediction. One DFA works in all contexts. We avoid using context not\n// necessarily because it's slower, although it can be, but because of the DFA\n// caching problem. The closure routine only considers the rule invocation stack\n// created during prediction beginning in the decision rule. For example, if\n// prediction occurs without invoking another rule's ATN, there are no context\n// stacks in the configurations. When lack of context leads to a conflict, we\n// don't know if it's an ambiguity or a weakness in the strong LL(*) parsing\n// strategy (versus full LL(*)).</p>\n//\n// <p>\n// When SLL yields a configuration set with conflict, we rewind the input and\n// retry the ATN simulation, this time using full outer context without adding\n// to the DFA. Configuration context stacks will be the full invocation stacks\n// from the start rule. If we get a conflict using full context, then we can\n// definitively say we have a true ambiguity for that input sequence. If we\n// don't get a conflict, it implies that the decision is sensitive to the outer\n// context. (It is not context-sensitive in the sense of context-sensitive\n// grammars.)</p>\n//\n// <p>\n// The next time we reach this DFA state with an SLL conflict, through DFA\n// simulation, we will again retry the ATN simulation using full context mode.\n// This is slow because we can't save the results and have to \"interpret\" the\n// ATN each time we get that input.</p>\n//\n// <p>\n// <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>\n//\n// <p>\n// We could cache results from full context to predicted alternative easily and\n// that saves a lot of time but doesn't work in presence of predicates. The set\n// of visible predicates from the ATN start state changes depending on the\n// context, because closure can fall off the end of a rule. I tried to cache\n// tuples (stack context, semantic context, predicted alt) but it was slower\n// than interpreting and much more complicated. Also required a huge amount of\n// memory. The goal is not to create the world's fastest parser anyway. I'd like\n// to keep this algorithm simple. By launching multiple threads, we can improve\n// the speed of parsing across a large number of files.</p>\n//\n// <p>\n// There is no strict ordering between the amount of input used by SLL vs LL,\n// which makes it really hard to build a cache for full context. Let's say that\n// we have input A B C that leads to an SLL conflict with full context X. That\n// implies that using X we might only use A B but we could also use A B C D to\n// resolve conflict. Input A B C D could predict alternative 1 in one position\n// in the input and A B C E could predict alternative 2 in another position in\n// input. The conflicting SLL configurations could still be non-unique in the\n// full context prediction, which would lead us to requiring more input than the\n// original A B C.\tTo make a\tprediction cache work, we have to track\tthe exact\n// input\tused during the previous prediction. That amounts to a cache that maps\n// X to a specific DFA for that context.</p>\n//\n// <p>\n// Something should be done for left-recursive expression predictions. They are\n// likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry\n// with full LL thing Sam does.</p>\n//\n// <p>\n// <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>\n//\n// <p>\n// We avoid doing full context retry when the outer context is empty, we did not\n// dip into the outer context by falling off the end of the decision state rule,\n// or when we force SLL mode.</p>\n//\n// <p>\n// As an example of the not dip into outer context case, consider as super\n// constructor calls versus function calls. One grammar might look like\n// this:</p>\n//\n// <pre>\n// ctorBody\n//   : '{' superCall? stat* '}'\n//   ;\n// </pre>\n//\n// <p>\n// Or, you might see something like</p>\n//\n// <pre>\n// stat\n//   : superCall ';'\n//   | expression ';'\n//   | ...\n//   ;\n// </pre>\n//\n// <p>\n// In both cases I believe that no closure operations will dip into the outer\n// context. In the first case ctorBody in the worst case will stop at the '}'.\n// In the 2nd case it should stop at the ';'. Both cases should stay within the\n// entry rule and not dip into the outer context.</p>\n//\n// <p>\n// <strong>PREDICATES</strong></p>\n//\n// <p>\n// Predicates are always evaluated if present in either SLL or LL both. SLL and\n// LL simulation deals with predicates differently. SLL collects predicates as\n// it performs closure operations like ANTLR v3 did. It delays predicate\n// evaluation until it reaches and accept state. This allows us to cache the SLL\n// ATN simulation whereas, if we had evaluated predicates on-the-fly during\n// closure, the DFA state configuration sets would be different and we couldn't\n// build up a suitable DFA.</p>\n//\n// <p>\n// When building a DFA accept state during ATN simulation, we evaluate any\n// predicates and return the sole semantically valid alternative. If there is\n// more than 1 alternative, we report an ambiguity. If there are 0 alternatives,\n// we throw an exception. Alternatives without predicates act like they have\n// true predicates. The simple way to think about it is to strip away all\n// alternatives with false predicates and choose the minimum alternative that\n// remains.</p>\n//\n// <p>\n// When we start in the DFA and reach an accept state that's predicated, we test\n// those and return the minimum semantically viable alternative. If no\n// alternatives are viable, we throw an exception.</p>\n//\n// <p>\n// During full LL ATN simulation, closure always evaluates predicates and\n// on-the-fly. This is crucial to reducing the configuration set size during\n// closure. It hits a landmine when parsing with the Java grammar, for example,\n// without this on-the-fly evaluation.</p>\n//\n// <p>\n// <strong>SHARING DFA</strong></p>\n//\n// <p>\n// All instances of the same parser share the same decision DFAs through a\n// static field. Each instance gets its own ATN simulator but they share the\n// same {@link //decisionToDFA} field. They also share a\n// {@link PredictionContextCache} object that makes sure that all\n// {@link PredictionContext} objects are shared among the DFA states. This makes\n// a big size difference.</p>\n//\n// <p>\n// <strong>THREAD SAFETY</strong></p>\n//\n// <p>\n// The {@link ParserATNSimulator} locks on the {@link //decisionToDFA} field when\n// it adds a new DFA object to that array. {@link //addDFAEdge}\n// locks on the DFA for the current decision when setting the\n// {@link DFAState//edges} field. {@link //addDFAState} locks on\n// the DFA for the current decision when looking up a DFA state to see if it\n// already exists. We must make sure that all requests to add DFA states that\n// are equivalent result in the same shared DFA object. This is because lots of\n// threads will be trying to update the DFA at once. The\n// {@link //addDFAState} method also locks inside the DFA lock\n// but this time on the shared context cache when it rebuilds the\n// configurations' {@link PredictionContext} objects using cached\n// subgraphs/nodes. No other locking occurs, even during DFA simulation. This is\n// safe as long as we can guarantee that all threads referencing\n// {@code s.edge[t]} get the same physical target {@link DFAState}, or\n// {@code null}. Once into the DFA, the DFA simulation does not reference the\n// {@link DFA//states} map. It follows the {@link DFAState//edges} field to new\n// targets. The DFA simulator will either find {@link DFAState//edges} to be\n// {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or\n// {@code dfa.edges[t]} to be non-null. The\n// {@link //addDFAEdge} method could be racing to set the field\n// but in either case the DFA simulator works; if {@code null}, and requests ATN\n// simulation. It could also race trying to get {@code dfa.edges[t]}, but either\n// way it will work because it's not doing a test and set operation.</p>\n//\n// <p>\n// <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage\n// Parsing)</strong></p>\n//\n// <p>\n// Sam pointed out that if SLL does not give a syntax error, then there is no\n// point in doing full LL, which is slower. We only have to try LL if we get a\n// syntax error. For maximum speed, Sam starts the parser set to pure SLL\n// mode with the {@link BailErrorStrategy}:</p>\n//\n// <pre>\n// parser.{@link Parser//getInterpreter() getInterpreter()}.{@link //setPredictionMode setPredictionMode}{@code (}{@link PredictionMode//SLL}{@code )};\n// parser.{@link Parser//setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());\n// </pre>\n//\n// <p>\n// If it does not get a syntax error, then we're done. If it does get a syntax\n// error, we need to retry with the combined SLL/LL strategy.</p>\n//\n// <p>\n// The reason this works is as follows. If there are no SLL conflicts, then the\n// grammar is SLL (at least for that input set). If there is an SLL conflict,\n// the full LL analysis must yield a set of viable alternatives which is a\n// subset of the alternatives reported by SLL. If the LL set is a singleton,\n// then the grammar is LL but not SLL. If the LL set is the same size as the SLL\n// set, the decision is SLL. If the LL set has size &gt; 1, then that decision\n// is truly ambiguous on the current input. If the LL set is smaller, then the\n// SLL conflict resolution might choose an alternative that the full LL would\n// rule out as a possibility based upon better context information. If that's\n// the case, then the SLL parse will definitely get an error because the full LL\n// analysis says it's not viable. If SLL conflict resolution chooses an\n// alternative within the LL set, them both SLL and LL would choose the same\n// alternative because they both choose the minimum of multiple conflicting\n// alternatives.</p>\n//\n// <p>\n// Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and\n// a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL\n// parsing will get an error because SLL will pursue alternative 1. If\n// <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will\n// choose the same alternative because alternative one is the minimum of either\n// set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax\n// error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>\n//\n// <p>\n// Of course, if the input is invalid, then we will get an error for sure in\n// both SLL and LL parsing. Erroneous input will therefore require 2 passes over\n// the input.</p>\n//\n\nvar Utils = require('./../Utils');\nvar Set = Utils.Set;\nvar BitSet = Utils.BitSet;\nvar DoubleDict = Utils.DoubleDict;\nvar ATN = require('./ATN').ATN;\nvar ATNConfig = require('./ATNConfig').ATNConfig;\nvar ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;\nvar Token = require('./../Token').Token;\nvar DFAState = require('./../dfa/DFAState').DFAState;\nvar PredPrediction = require('./../dfa/DFAState').PredPrediction;\nvar ATNSimulator = require('./ATNSimulator').ATNSimulator;\nvar PredictionMode = require('./PredictionMode').PredictionMode;\nvar RuleContext = require('./../RuleContext').RuleContext;\nvar ParserRuleContext = require('./../ParserRuleContext').ParserRuleContext;\nvar SemanticContext = require('./SemanticContext').SemanticContext;\nvar StarLoopEntryState = require('./ATNState').StarLoopEntryState;\nvar RuleStopState = require('./ATNState').RuleStopState;\nvar PredictionContext = require('./../PredictionContext').PredictionContext;\nvar Interval = require('./../IntervalSet').Interval;\nvar Transitions = require('./Transition');\nvar Transition = Transitions.Transition;\nvar SetTransition = Transitions.SetTransition;\nvar NotSetTransition = Transitions.NotSetTransition;\nvar RuleTransition = Transitions.RuleTransition;\nvar ActionTransition = Transitions.ActionTransition;\nvar NoViableAltException = require('./../error/Errors').NoViableAltException;\n\nvar SingletonPredictionContext = require('./../PredictionContext').SingletonPredictionContext;\nvar predictionContextFromRuleContext = require('./../PredictionContext').predictionContextFromRuleContext;\n\nfunction ParserATNSimulator(parser, atn, decisionToDFA, sharedContextCache) {\n\tATNSimulator.call(this, atn, sharedContextCache);\n    this.parser = parser;\n    this.decisionToDFA = decisionToDFA;\n    // SLL, LL, or LL + exact ambig detection?//\n    this.predictionMode = PredictionMode.LL;\n    // LAME globals to avoid parameters!!!!! I need these down deep in predTransition\n    this._input = null;\n    this._startIndex = 0;\n    this._outerContext = null;\n    this._dfa = null;\n    // Each prediction operation uses a cache for merge of prediction contexts.\n    //  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap\n    //  isn't synchronized but we're ok since two threads shouldn't reuse same\n    //  parser/atnsim object because it can only handle one input at a time.\n    //  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid\n    //  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should\n    //  also be examined during cache lookup.\n    //\n    this.mergeCache = null;\n    return this;\n}\n\nParserATNSimulator.prototype = Object.create(ATNSimulator.prototype);\nParserATNSimulator.prototype.constructor = ParserATNSimulator;\n\nParserATNSimulator.prototype.debug = false;\nParserATNSimulator.prototype.debug_list_atn_decisions = false;\nParserATNSimulator.prototype.dfa_debug = false;\nParserATNSimulator.prototype.retry_debug = false;\n\n\nParserATNSimulator.prototype.reset = function() {\n};\n\nParserATNSimulator.prototype.adaptivePredict = function(input, decision, outerContext) {\n    if (this.debug || this.debug_list_atn_decisions) {\n        console.log(\"adaptivePredict decision \" + decision +\n                               \" exec LA(1)==\" + this.getLookaheadName(input) +\n                               \" line \" + input.LT(1).line + \":\" +\n                               input.LT(1).column);\n    }\n    this._input = input;\n    this._startIndex = input.index;\n    this._outerContext = outerContext;\n    \n    var dfa = this.decisionToDFA[decision];\n    this._dfa = dfa;\n    var m = input.mark();\n    var index = input.index;\n\n    // Now we are certain to have a specific decision's DFA\n    // But, do we still need an initial state?\n    try {\n        var s0;\n        if (dfa.precedenceDfa) {\n            // the start state for a precedence DFA depends on the current\n            // parser precedence, and is provided by a DFA method.\n            s0 = dfa.getPrecedenceStartState(this.parser.getPrecedence());\n        } else {\n            // the start state for a \"regular\" DFA is just s0\n            s0 = dfa.s0;\n        }\n        if (s0===null) {\n            if (outerContext===null) {\n                outerContext = RuleContext.EMPTY;\n            }\n            if (this.debug || this.debug_list_atn_decisions) {\n                console.log(\"predictATN decision \" + dfa.decision +\n                                   \" exec LA(1)==\" + this.getLookaheadName(input) +\n                                   \", outerContext=\" + outerContext.toString(this.parser.ruleNames));\n            }\n            // If this is not a precedence DFA, we check the ATN start state\n            // to determine if this ATN start state is the decision for the\n            // closure block that determines whether a precedence rule\n            // should continue or complete.\n            //\n            if (!dfa.precedenceDfa && (dfa.atnStartState instanceof StarLoopEntryState)) {\n                if (dfa.atnStartState.precedenceRuleDecision) {\n                    dfa.setPrecedenceDfa(true);\n                }\n            }\n            var fullCtx = false;\n            var s0_closure = this.computeStartState(dfa.atnStartState, RuleContext.EMPTY, fullCtx);\n\n            if( dfa.precedenceDfa) {\n                // If this is a precedence DFA, we use applyPrecedenceFilter\n                // to convert the computed start state to a precedence start\n                // state. We then use DFA.setPrecedenceStartState to set the\n                // appropriate start state for the precedence level rather\n                // than simply setting DFA.s0.\n                //\n                s0_closure = this.applyPrecedenceFilter(s0_closure);\n                s0 = this.addDFAState(dfa, new DFAState(null, s0_closure));\n                dfa.setPrecedenceStartState(this.parser.getPrecedence(), s0);\n            } else {\n                s0 = this.addDFAState(dfa, new DFAState(null, s0_closure));\n                dfa.s0 = s0;\n            }\n        }\n        var alt = this.execATN(dfa, s0, input, index, outerContext);\n        if (this.debug) {\n            console.log(\"DFA after predictATN: \" + dfa.toString(this.parser.literalNames));\n        }\n        return alt;\n    } finally {\n        this._dfa = null;\n        this.mergeCache = null; // wack cache after each prediction\n        input.seek(index);\n        input.release(m);\n    }\n};\n// Performs ATN simulation to compute a predicted alternative based\n//  upon the remaining input, but also updates the DFA cache to avoid\n//  having to traverse the ATN again for the same input sequence.\n\n// There are some key conditions we're looking for after computing a new\n// set of ATN configs (proposed DFA state):\n      // if the set is empty, there is no viable alternative for current symbol\n      // does the state uniquely predict an alternative?\n      // does the state have a conflict that would prevent us from\n      //   putting it on the work list?\n\n// We also have some key operations to do:\n      // add an edge from previous DFA state to potentially new DFA state, D,\n      //   upon current symbol but only if adding to work list, which means in all\n      //   cases except no viable alternative (and possibly non-greedy decisions?)\n      // collecting predicates and adding semantic context to DFA accept states\n      // adding rule context to context-sensitive DFA accept states\n      // consuming an input symbol\n      // reporting a conflict\n      // reporting an ambiguity\n      // reporting a context sensitivity\n      // reporting insufficient predicates\n\n// cover these cases:\n//    dead end\n//    single alt\n//    single alt + preds\n//    conflict\n//    conflict + preds\n//\nParserATNSimulator.prototype.execATN = function(dfa, s0, input, startIndex, outerContext ) {\n    if (this.debug || this.debug_list_atn_decisions) {\n        console.log(\"execATN decision \" + dfa.decision +\n                \" exec LA(1)==\" + this.getLookaheadName(input) +\n                \" line \" + input.LT(1).line + \":\" + input.LT(1).column);\n    }\n    var alt;\n    var previousD = s0;\n\n    if (this.debug) {\n        console.log(\"s0 = \" + s0);\n    }\n    var t = input.LA(1);\n    while(true) { // while more work\n        var D = this.getExistingTargetState(previousD, t);\n        if(D===null) {\n            D = this.computeTargetState(dfa, previousD, t);\n        }\n        if(D===ATNSimulator.ERROR) {\n            // if any configs in previous dipped into outer context, that\n            // means that input up to t actually finished entry rule\n            // at least for SLL decision. Full LL doesn't dip into outer\n            // so don't need special case.\n            // We will get an error no matter what so delay until after\n            // decision; better error message. Also, no reachable target\n            // ATN states in SLL implies LL will also get nowhere.\n            // If conflict in states that dip out, choose min since we\n            // will get error no matter what.\n            var e = this.noViableAlt(input, outerContext, previousD.configs, startIndex);\n            input.seek(startIndex);\n            alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext);\n            if(alt!==ATN.INVALID_ALT_NUMBER) {\n                return alt;\n            } else {\n                throw e;\n            }\n        }\n        if(D.requiresFullContext && this.predictionMode !== PredictionMode.SLL) {\n            // IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)\n            var conflictingAlts = null;\n            if (D.predicates!==null) {\n                if (this.debug) {\n                    console.log(\"DFA state has preds in DFA sim LL failover\");\n                }\n                var conflictIndex = input.index;\n                if(conflictIndex !== startIndex) {\n                    input.seek(startIndex);\n                }\n                conflictingAlts = this.evalSemanticContext(D.predicates, outerContext, true);\n                if (conflictingAlts.length===1) {\n                    if(this.debug) {\n                        console.log(\"Full LL avoided\");\n                    }\n                    return conflictingAlts.minValue();\n                }\n                if (conflictIndex !== startIndex) {\n                    // restore the index so reporting the fallback to full\n                    // context occurs with the index at the correct spot\n                    input.seek(conflictIndex);\n                }\n            }\n            if (this.dfa_debug) {\n                console.log(\"ctx sensitive state \" + outerContext +\" in \" + D);\n            }\n            var fullCtx = true;\n            var s0_closure = this.computeStartState(dfa.atnStartState, outerContext, fullCtx);\n            this.reportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.index);\n            alt = this.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext);\n            return alt;\n        }\n        if (D.isAcceptState) {\n            if (D.predicates===null) {\n                return D.prediction;\n            }\n            var stopIndex = input.index;\n            input.seek(startIndex);\n            var alts = this.evalSemanticContext(D.predicates, outerContext, true);\n            if (alts.length===0) {\n                throw this.noViableAlt(input, outerContext, D.configs, startIndex);\n            } else if (alts.length===1) {\n                return alts.minValue();\n            } else {\n                // report ambiguity after predicate evaluation to make sure the correct set of ambig alts is reported.\n                this.reportAmbiguity(dfa, D, startIndex, stopIndex, false, alts, D.configs);\n                return alts.minValue();\n            }\n        }\n        previousD = D;\n\n        if (t !== Token.EOF) {\n            input.consume();\n            t = input.LA(1);\n        }\n    }\n};\n//\n// Get an existing target state for an edge in the DFA. If the target state\n// for the edge has not yet been computed or is otherwise not available,\n// this method returns {@code null}.\n//\n// @param previousD The current DFA state\n// @param t The next input symbol\n// @return The existing target DFA state for the given input symbol\n// {@code t}, or {@code null} if the target state for this edge is not\n// already cached\n//\nParserATNSimulator.prototype.getExistingTargetState = function(previousD, t) {\n    var edges = previousD.edges;\n    if (edges===null) {\n        return null;\n    } else {\n        return edges[t + 1] || null;\n    }\n};\n//\n// Compute a target state for an edge in the DFA, and attempt to add the\n// computed state and corresponding edge to the DFA.\n//\n// @param dfa The DFA\n// @param previousD The current DFA state\n// @param t The next input symbol\n//\n// @return The computed target DFA state for the given input symbol\n// {@code t}. If {@code t} does not lead to a valid DFA state, this method\n// returns {@link //ERROR}.\n//\nParserATNSimulator.prototype.computeTargetState = function(dfa, previousD, t) {\n   var reach = this.computeReachSet(previousD.configs, t, false);\n    if(reach===null) {\n        this.addDFAEdge(dfa, previousD, t, ATNSimulator.ERROR);\n        return ATNSimulator.ERROR;\n    }\n    // create new target state; we'll add to DFA after it's complete\n    var D = new DFAState(null, reach);\n\n    var predictedAlt = this.getUniqueAlt(reach);\n\n    if (this.debug) {\n        var altSubSets = PredictionMode.getConflictingAltSubsets(reach);\n        console.log(\"SLL altSubSets=\" + Utils.arrayToString(altSubSets) +\n                    \", previous=\" + previousD.configs +\n                    \", configs=\" + reach +\n                    \", predict=\" + predictedAlt +\n                    \", allSubsetsConflict=\" +\n                    PredictionMode.allSubsetsConflict(altSubSets) + \", conflictingAlts=\" +\n                    this.getConflictingAlts(reach));\n    }\n    if (predictedAlt!==ATN.INVALID_ALT_NUMBER) {\n        // NO CONFLICT, UNIQUELY PREDICTED ALT\n        D.isAcceptState = true;\n        D.configs.uniqueAlt = predictedAlt;\n        D.prediction = predictedAlt;\n    } else if (PredictionMode.hasSLLConflictTerminatingPrediction(this.predictionMode, reach)) {\n        // MORE THAN ONE VIABLE ALTERNATIVE\n        D.configs.conflictingAlts = this.getConflictingAlts(reach);\n        D.requiresFullContext = true;\n        // in SLL-only mode, we will stop at this state and return the minimum alt\n        D.isAcceptState = true;\n        D.prediction = D.configs.conflictingAlts.minValue();\n    }\n    if (D.isAcceptState && D.configs.hasSemanticContext) {\n        this.predicateDFAState(D, this.atn.getDecisionState(dfa.decision));\n        if( D.predicates!==null) {\n            D.prediction = ATN.INVALID_ALT_NUMBER;\n        }\n    }\n    // all adds to dfa are done after we've created full D state\n    D = this.addDFAEdge(dfa, previousD, t, D);\n    return D;\n};\n\nParserATNSimulator.prototype.predicateDFAState = function(dfaState, decisionState) {\n    // We need to test all predicates, even in DFA states that\n    // uniquely predict alternative.\n    var nalts = decisionState.transitions.length;\n    // Update DFA so reach becomes accept state with (predicate,alt)\n    // pairs if preds found for conflicting alts\n    var altsToCollectPredsFrom = this.getConflictingAltsOrUniqueAlt(dfaState.configs);\n    var altToPred = this.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts);\n    if (altToPred!==null) {\n        dfaState.predicates = this.getPredicatePredictions(altsToCollectPredsFrom, altToPred);\n        dfaState.prediction = ATN.INVALID_ALT_NUMBER; // make sure we use preds\n    } else {\n        // There are preds in configs but they might go away\n        // when OR'd together like {p}? || NONE == NONE. If neither\n        // alt has preds, resolve to min alt\n        dfaState.prediction = altsToCollectPredsFrom.minValue();\n    }\n};\n\n// comes back with reach.uniqueAlt set to a valid alt\nParserATNSimulator.prototype.execATNWithFullContext = function(dfa, D, // how far we got before failing over\n                                     s0,\n                                     input,\n                                     startIndex,\n                                     outerContext) {\n    if (this.debug || this.debug_list_atn_decisions) {\n        console.log(\"execATNWithFullContext \"+s0);\n    }\n    var fullCtx = true;\n    var foundExactAmbig = false;\n    var reach = null;\n    var previous = s0;\n    input.seek(startIndex);\n    var t = input.LA(1);\n    var predictedAlt = -1;\n    while (true) { // while more work\n        reach = this.computeReachSet(previous, t, fullCtx);\n        if (reach===null) {\n            // if any configs in previous dipped into outer context, that\n            // means that input up to t actually finished entry rule\n            // at least for LL decision. Full LL doesn't dip into outer\n            // so don't need special case.\n            // We will get an error no matter what so delay until after\n            // decision; better error message. Also, no reachable target\n            // ATN states in SLL implies LL will also get nowhere.\n            // If conflict in states that dip out, choose min since we\n            // will get error no matter what.\n            var e = this.noViableAlt(input, outerContext, previous, startIndex);\n            input.seek(startIndex);\n            var alt = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext);\n            if(alt!==ATN.INVALID_ALT_NUMBER) {\n                return alt;\n            } else {\n                throw e;\n            }\n        }\n        var altSubSets = PredictionMode.getConflictingAltSubsets(reach);\n        if(this.debug) {\n            console.log(\"LL altSubSets=\" + altSubSets + \", predict=\" +\n                  PredictionMode.getUniqueAlt(altSubSets) + \", resolvesToJustOneViableAlt=\" +\n                  PredictionMode.resolvesToJustOneViableAlt(altSubSets));\n        }\n        reach.uniqueAlt = this.getUniqueAlt(reach);\n        // unique prediction?\n        if(reach.uniqueAlt!==ATN.INVALID_ALT_NUMBER) {\n            predictedAlt = reach.uniqueAlt;\n            break;\n        } else if (this.predictionMode !== PredictionMode.LL_EXACT_AMBIG_DETECTION) {\n            predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets);\n            if(predictedAlt !== ATN.INVALID_ALT_NUMBER) {\n                break;\n            }\n        } else {\n            // In exact ambiguity mode, we never try to terminate early.\n            // Just keeps scarfing until we know what the conflict is\n            if (PredictionMode.allSubsetsConflict(altSubSets) && PredictionMode.allSubsetsEqual(altSubSets)) {\n                foundExactAmbig = true;\n                predictedAlt = PredictionMode.getSingleViableAlt(altSubSets);\n                break;\n            }\n            // else there are multiple non-conflicting subsets or\n            // we're not sure what the ambiguity is yet.\n            // So, keep going.\n        }\n        previous = reach;\n        if( t !== Token.EOF) {\n            input.consume();\n            t = input.LA(1);\n        }\n    }\n    // If the configuration set uniquely predicts an alternative,\n    // without conflict, then we know that it's a full LL decision\n    // not SLL.\n    if (reach.uniqueAlt !== ATN.INVALID_ALT_NUMBER ) {\n        this.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index);\n        return predictedAlt;\n    }\n    // We do not check predicates here because we have checked them\n    // on-the-fly when doing full context prediction.\n\n    //\n    // In non-exact ambiguity detection mode, we might\tactually be able to\n    // detect an exact ambiguity, but I'm not going to spend the cycles\n    // needed to check. We only emit ambiguity warnings in exact ambiguity\n    // mode.\n    //\n    // For example, we might know that we have conflicting configurations.\n    // But, that does not mean that there is no way forward without a\n    // conflict. It's possible to have nonconflicting alt subsets as in:\n\n    // altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]\n\n    // from\n    //\n    //    [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),\n    //     (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]\n    //\n    // In this case, (17,1,[5 $]) indicates there is some next sequence that\n    // would resolve this without conflict to alternative 1. Any other viable\n    // next sequence, however, is associated with a conflict.  We stop\n    // looking for input because no amount of further lookahead will alter\n    // the fact that we should predict alternative 1.  We just can't say for\n    // sure that there is an ambiguity without looking further.\n\n    this.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, null, reach);\n\n    return predictedAlt;\n};\n\nParserATNSimulator.prototype.computeReachSet = function(closure, t, fullCtx) {\n    if (this.debug) {\n        console.log(\"in computeReachSet, starting closure: \" + closure);\n    }\n    if( this.mergeCache===null) {\n        this.mergeCache = new DoubleDict();\n    }\n    var intermediate = new ATNConfigSet(fullCtx);\n\n    // Configurations already in a rule stop state indicate reaching the end\n    // of the decision rule (local context) or end of the start rule (full\n    // context). Once reached, these configurations are never updated by a\n    // closure operation, so they are handled separately for the performance\n    // advantage of having a smaller intermediate set when calling closure.\n    //\n    // For full-context reach operations, separate handling is required to\n    // ensure that the alternative matching the longest overall sequence is\n    // chosen when multiple such configurations can match the input.\n    \n    var skippedStopStates = null;\n\n    // First figure out where we can reach on input t\n    for (var i=0; i<closure.items.length;i++) {\n        var c = closure.items[i];\n        if(this.debug) {\n            console.log(\"testing \" + this.getTokenName(t) + \" at \" + c);\n        }\n        if (c.state instanceof RuleStopState) {\n            if (fullCtx || t === Token.EOF) {\n                if (skippedStopStates===null) {\n                    skippedStopStates = [];\n                }\n                skippedStopStates.push(c);\n                if(this.debug) {\n                    console.log(\"added \" + c + \" to skippedStopStates\");\n                }\n            }\n            continue;\n        }\n        for(var j=0;j<c.state.transitions.length;j++) {\n            var trans = c.state.transitions[j];\n            var target = this.getReachableTarget(trans, t);\n            if (target!==null) {\n                var cfg = new ATNConfig({state:target}, c);\n                intermediate.add(cfg, this.mergeCache);\n                if(this.debug) {\n                    console.log(\"added \" + cfg + \" to intermediate\");\n                }\n            }\n        }\n    }\n    // Now figure out where the reach operation can take us...\n    var reach = null;\n\n    // This block optimizes the reach operation for intermediate sets which\n    // trivially indicate a termination state for the overall\n    // adaptivePredict operation.\n    //\n    // The conditions assume that intermediate\n    // contains all configurations relevant to the reach set, but this\n    // condition is not true when one or more configurations have been\n    // withheld in skippedStopStates, or when the current symbol is EOF.\n    //\n    if (skippedStopStates===null && t!==Token.EOF) {\n        if (intermediate.items.length===1) {\n            // Don't pursue the closure if there is just one state.\n            // It can only have one alternative; just add to result\n            // Also don't pursue the closure if there is unique alternative\n            // among the configurations.\n            reach = intermediate;\n        } else if (this.getUniqueAlt(intermediate)!==ATN.INVALID_ALT_NUMBER) {\n            // Also don't pursue the closure if there is unique alternative\n            // among the configurations.\n            reach = intermediate;\n        }\n    }\n    // If the reach set could not be trivially determined, perform a closure\n    // operation on the intermediate set to compute its initial value.\n    //\n    if (reach===null) {\n        reach = new ATNConfigSet(fullCtx);\n        var closureBusy = new Set();\n        var treatEofAsEpsilon = t === Token.EOF;\n        for (var k=0; k<intermediate.items.length;k++) {\n            this.closure(intermediate.items[k], reach, closureBusy, false, fullCtx, treatEofAsEpsilon);\n        }\n    }\n    if (t === Token.EOF) {\n        // After consuming EOF no additional input is possible, so we are\n        // only interested in configurations which reached the end of the\n        // decision rule (local context) or end of the start rule (full\n        // context). Update reach to contain only these configurations. This\n        // handles both explicit EOF transitions in the grammar and implicit\n        // EOF transitions following the end of the decision or start rule.\n        //\n        // When reach==intermediate, no closure operation was performed. In\n        // this case, removeAllConfigsNotInRuleStopState needs to check for\n        // reachable rule stop states as well as configurations already in\n        // a rule stop state.\n        //\n        // This is handled before the configurations in skippedStopStates,\n        // because any configurations potentially added from that list are\n        // already guaranteed to meet this condition whether or not it's\n        // required.\n        //\n        reach = this.removeAllConfigsNotInRuleStopState(reach, reach === intermediate);\n    }\n    // If skippedStopStates!==null, then it contains at least one\n    // configuration. For full-context reach operations, these\n    // configurations reached the end of the start rule, in which case we\n    // only add them back to reach if no configuration during the current\n    // closure operation reached such a state. This ensures adaptivePredict\n    // chooses an alternative matching the longest overall sequence when\n    // multiple alternatives are viable.\n    //\n    if (skippedStopStates!==null && ( (! fullCtx) || (! PredictionMode.hasConfigInRuleStopState(reach)))) {\n        for (var l=0; l<skippedStopStates.length;l++) {\n            reach.add(skippedStopStates[l], this.mergeCache);\n        }\n    }\n    if (reach.items.length===0) {\n        return null;\n    } else {\n        return reach;\n    }\n};\n//\n// Return a configuration set containing only the configurations from\n// {@code configs} which are in a {@link RuleStopState}. If all\n// configurations in {@code configs} are already in a rule stop state, this\n// method simply returns {@code configs}.\n//\n// <p>When {@code lookToEndOfRule} is true, this method uses\n// {@link ATN//nextTokens} for each configuration in {@code configs} which is\n// not already in a rule stop state to see if a rule stop state is reachable\n// from the configuration via epsilon-only transitions.</p>\n//\n// @param configs the configuration set to update\n// @param lookToEndOfRule when true, this method checks for rule stop states\n// reachable by epsilon-only transitions from each configuration in\n// {@code configs}.\n//\n// @return {@code configs} if all configurations in {@code configs} are in a\n// rule stop state, otherwise return a new configuration set containing only\n// the configurations from {@code configs} which are in a rule stop state\n//\nParserATNSimulator.prototype.removeAllConfigsNotInRuleStopState = function(configs, lookToEndOfRule) {\n    if (PredictionMode.allConfigsInRuleStopStates(configs)) {\n        return configs;\n    }\n    var result = new ATNConfigSet(configs.fullCtx);\n    for(var i=0; i<configs.items.length;i++) {\n        var config = configs.items[i];\n        if (config.state instanceof RuleStopState) {\n            result.add(config, this.mergeCache);\n            continue;\n        }\n        if (lookToEndOfRule && config.state.epsilonOnlyTransitions) {\n            var nextTokens = this.atn.nextTokens(config.state);\n            if (nextTokens.contains(Token.EPSILON)) {\n                var endOfRuleState = this.atn.ruleToStopState[config.state.ruleIndex];\n                result.add(new ATNConfig({state:endOfRuleState}, config), this.mergeCache);\n            }\n        }\n    }\n    return result;\n};\n\nParserATNSimulator.prototype.computeStartState = function(p, ctx, fullCtx) {\n    // always at least the implicit call to start rule\n    var initialContext = predictionContextFromRuleContext(this.atn, ctx);\n    var configs = new ATNConfigSet(fullCtx);\n    for(var i=0;i<p.transitions.length;i++) {\n        var target = p.transitions[i].target;\n        var c = new ATNConfig({ state:target, alt:i+1, context:initialContext }, null);\n        var closureBusy = new Set();\n        this.closure(c, configs, closureBusy, true, fullCtx, false);\n    }\n    return configs;\n};\n\n//\n// This method transforms the start state computed by\n// {@link //computeStartState} to the special start state used by a\n// precedence DFA for a particular precedence value. The transformation\n// process applies the following changes to the start state's configuration\n// set.\n//\n// <ol>\n// <li>Evaluate the precedence predicates for each configuration using\n// {@link SemanticContext//evalPrecedence}.</li>\n// <li>Remove all configurations which predict an alternative greater than\n// 1, for which another configuration that predicts alternative 1 is in the\n// same ATN state with the same prediction context. This transformation is\n// valid for the following reasons:\n// <ul>\n// <li>The closure block cannot contain any epsilon transitions which bypass\n// the body of the closure, so all states reachable via alternative 1 are\n// part of the precedence alternatives of the transformed left-recursive\n// rule.</li>\n// <li>The \"primary\" portion of a left recursive rule cannot contain an\n// epsilon transition, so the only way an alternative other than 1 can exist\n// in a state that is also reachable via alternative 1 is by nesting calls\n// to the left-recursive rule, with the outer calls not being at the\n// preferred precedence level.</li>\n// </ul>\n// </li>\n// </ol>\n//\n// <p>\n// The prediction context must be considered by this filter to address\n// situations like the following.\n// </p>\n// <code>\n// <pre>\n// grammar TA;\n// prog: statement* EOF;\n// statement: letterA | statement letterA 'b' ;\n// letterA: 'a';\n// </pre>\n// </code>\n// <p>\n// If the above grammar, the ATN state immediately before the token\n// reference {@code 'a'} in {@code letterA} is reachable from the left edge\n// of both the primary and closure blocks of the left-recursive rule\n// {@code statement}. The prediction context associated with each of these\n// configurations distinguishes between them, and prevents the alternative\n// which stepped out to {@code prog} (and then back in to {@code statement}\n// from being eliminated by the filter.\n// </p>\n//\n// @param configs The configuration set computed by\n// {@link //computeStartState} as the start state for the DFA.\n// @return The transformed configuration set representing the start state\n// for a precedence DFA at a particular precedence level (determined by\n// calling {@link Parser//getPrecedence}).\n//\nParserATNSimulator.prototype.applyPrecedenceFilter = function(configs) {\n\tvar config;\n\tvar statesFromAlt1 = [];\n    var configSet = new ATNConfigSet(configs.fullCtx);\n    for(var i=0; i<configs.items.length; i++) {\n        config = configs.items[i];\n        // handle alt 1 first\n        if (config.alt !== 1) {\n            continue;\n        }\n        var updatedContext = config.semanticContext.evalPrecedence(this.parser, this._outerContext);\n        if (updatedContext===null) {\n            // the configuration was eliminated\n            continue;\n        }\n        statesFromAlt1[config.state.stateNumber] = config.context;\n        if (updatedContext !== config.semanticContext) {\n            configSet.add(new ATNConfig({semanticContext:updatedContext}, config), this.mergeCache);\n        } else {\n            configSet.add(config, this.mergeCache);\n        }\n    }\n    for(i=0; i<configs.items.length; i++) {\n        config = configs.items[i];\n        if (config.alt === 1) {\n            // already handled\n            continue;\n        }\n        // In the future, this elimination step could be updated to also\n        // filter the prediction context for alternatives predicting alt>1\n        // (basically a graph subtraction algorithm).\n\t\tif (!config.precedenceFilterSuppressed) {\n            var context = statesFromAlt1[config.state.stateNumber] || null;\n            if (context!==null && context.equals(config.context)) {\n                // eliminated\n                continue;\n            }\n\t\t}\n        configSet.add(config, this.mergeCache);\n    }\n    return configSet;\n};\n\nParserATNSimulator.prototype.getReachableTarget = function(trans, ttype) {\n    if (trans.matches(ttype, 0, this.atn.maxTokenType)) {\n        return trans.target;\n    } else {\n        return null;\n    }\n};\n\nParserATNSimulator.prototype.getPredsForAmbigAlts = function(ambigAlts, configs, nalts) {\n    // REACH=[1|1|[]|0:0, 1|2|[]|0:1]\n    // altToPred starts as an array of all null contexts. The entry at index i\n    // corresponds to alternative i. altToPred[i] may have one of three values:\n    //   1. null: no ATNConfig c is found such that c.alt==i\n    //   2. SemanticContext.NONE: At least one ATNConfig c exists such that\n    //      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,\n    //      alt i has at least one unpredicated config.\n    //   3. Non-NONE Semantic Context: There exists at least one, and for all\n    //      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.\n    //\n    // From this, it is clear that NONE||anything==NONE.\n    //\n    var altToPred = [];\n    for(var i=0;i<configs.items.length;i++) {\n        var c = configs.items[i];\n        if(ambigAlts.contains( c.alt )) {\n            altToPred[c.alt] = SemanticContext.orContext(altToPred[c.alt] || null, c.semanticContext);\n        }\n    }\n    var nPredAlts = 0;\n    for (i =1;i< nalts+1;i++) {\n        var pred = altToPred[i] || null;\n        if (pred===null) {\n            altToPred[i] = SemanticContext.NONE;\n        } else if (pred !== SemanticContext.NONE) {\n            nPredAlts += 1;\n        }\n    }\n    // nonambig alts are null in altToPred\n    if (nPredAlts===0) {\n        altToPred = null;\n    }\n    if (this.debug) {\n        console.log(\"getPredsForAmbigAlts result \" + Utils.arrayToString(altToPred));\n    }\n    return altToPred;\n};\n\nParserATNSimulator.prototype.getPredicatePredictions = function(ambigAlts, altToPred) {\n    var pairs = [];\n    var containsPredicate = false;\n    for (var i=1; i<altToPred.length;i++) {\n        var pred = altToPred[i];\n        // unpredicated is indicated by SemanticContext.NONE\n        if( ambigAlts!==null && ambigAlts.contains( i )) {\n            pairs.push(new PredPrediction(pred, i));\n        }\n        if (pred !== SemanticContext.NONE) {\n            containsPredicate = true;\n        }\n    }\n    if (! containsPredicate) {\n        return null;\n    }\n    return pairs;\n};\n\n//\n// This method is used to improve the localization of error messages by\n// choosing an alternative rather than throwing a\n// {@link NoViableAltException} in particular prediction scenarios where the\n// {@link //ERROR} state was reached during ATN simulation.\n//\n// <p>\n// The default implementation of this method uses the following\n// algorithm to identify an ATN configuration which successfully parsed the\n// decision entry rule. Choosing such an alternative ensures that the\n// {@link ParserRuleContext} returned by the calling rule will be complete\n// and valid, and the syntax error will be reported later at a more\n// localized location.</p>\n//\n// <ul>\n// <li>If a syntactically valid path or paths reach the end of the decision rule and\n// they are semantically valid if predicated, return the min associated alt.</li>\n// <li>Else, if a semantically invalid but syntactically valid path exist\n// or paths exist, return the minimum associated alt.\n// </li>\n// <li>Otherwise, return {@link ATN//INVALID_ALT_NUMBER}.</li>\n// </ul>\n//\n// <p>\n// In some scenarios, the algorithm described above could predict an\n// alternative which will result in a {@link FailedPredicateException} in\n// the parser. Specifically, this could occur if the <em>only</em> configuration\n// capable of successfully parsing to the end of the decision rule is\n// blocked by a semantic predicate. By choosing this alternative within\n// {@link //adaptivePredict} instead of throwing a\n// {@link NoViableAltException}, the resulting\n// {@link FailedPredicateException} in the parser will identify the specific\n// predicate which is preventing the parser from successfully parsing the\n// decision rule, which helps developers identify and correct logic errors\n// in semantic predicates.\n// </p>\n//\n// @param configs The ATN configurations which were valid immediately before\n// the {@link //ERROR} state was reached\n// @param outerContext The is the \\gamma_0 initial parser context from the paper\n// or the parser stack at the instant before prediction commences.\n//\n// @return The value to return from {@link //adaptivePredict}, or\n// {@link ATN//INVALID_ALT_NUMBER} if a suitable alternative was not\n// identified and {@link //adaptivePredict} should report an error instead.\n//\nParserATNSimulator.prototype.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule = function(configs, outerContext) {\n    var cfgs = this.splitAccordingToSemanticValidity(configs, outerContext);\n    var semValidConfigs = cfgs[0];\n    var semInvalidConfigs = cfgs[1];\n    var alt = this.getAltThatFinishedDecisionEntryRule(semValidConfigs);\n    if (alt!==ATN.INVALID_ALT_NUMBER) { // semantically/syntactically viable path exists\n        return alt;\n    }\n    // Is there a syntactically valid path with a failed pred?\n    if (semInvalidConfigs.items.length>0) {\n        alt = this.getAltThatFinishedDecisionEntryRule(semInvalidConfigs);\n        if (alt!==ATN.INVALID_ALT_NUMBER) { // syntactically viable path exists\n            return alt;\n        }\n    }\n    return ATN.INVALID_ALT_NUMBER;\n};\n    \nParserATNSimulator.prototype.getAltThatFinishedDecisionEntryRule = function(configs) {\n    var alts = [];\n    for(var i=0;i<configs.items.length; i++) {\n        var c = configs.items[i];\n        if (c.reachesIntoOuterContext>0 || ((c.state instanceof RuleStopState) && c.context.hasEmptyPath())) {\n            if(alts.indexOf(c.alt)<0) {\n                alts.push(c.alt);\n            }\n        }\n    }\n    if (alts.length===0) {\n        return ATN.INVALID_ALT_NUMBER;\n    } else {\n        return Math.min.apply(null, alts);\n    }\n};\n// Walk the list of configurations and split them according to\n//  those that have preds evaluating to true/false.  If no pred, assume\n//  true pred and include in succeeded set.  Returns Pair of sets.\n//\n//  Create a new set so as not to alter the incoming parameter.\n//\n//  Assumption: the input stream has been restored to the starting point\n//  prediction, which is where predicates need to evaluate.\n//\nParserATNSimulator.prototype.splitAccordingToSemanticValidity = function( configs, outerContext) {\n    var succeeded = new ATNConfigSet(configs.fullCtx);\n    var failed = new ATNConfigSet(configs.fullCtx);\n    for(var i=0;i<configs.items.length; i++) {\n        var c = configs.items[i];\n        if (c.semanticContext !== SemanticContext.NONE) {\n            var predicateEvaluationResult = c.semanticContext.evaluate(this.parser, outerContext);\n            if (predicateEvaluationResult) {\n                succeeded.add(c);\n            } else {\n                failed.add(c);\n            }\n        } else {\n            succeeded.add(c);\n        }\n    }\n    return [succeeded, failed];\n};\n\n// Look through a list of predicate/alt pairs, returning alts for the\n//  pairs that win. A {@code NONE} predicate indicates an alt containing an\n//  unpredicated config which behaves as \"always true.\" If !complete\n//  then we stop at the first predicate that evaluates to true. This\n//  includes pairs with null predicates.\n//\nParserATNSimulator.prototype.evalSemanticContext = function(predPredictions, outerContext, complete) {\n    var predictions = new BitSet();\n    for(var i=0;i<predPredictions.length;i++) {\n    \tvar pair = predPredictions[i];\n        if (pair.pred === SemanticContext.NONE) {\n            predictions.add(pair.alt);\n            if (! complete) {\n                break;\n            }\n            continue;\n        }\n        var predicateEvaluationResult = pair.pred.evaluate(this.parser, outerContext);\n        if (this.debug || this.dfa_debug) {\n            console.log(\"eval pred \" + pair + \"=\" + predicateEvaluationResult);\n        }\n        if (predicateEvaluationResult) {\n            if (this.debug || this.dfa_debug) {\n                console.log(\"PREDICT \" + pair.alt);\n            }\n            predictions.add(pair.alt);\n            if (! complete) {\n                break;\n            }\n        }\n    }\n    return predictions;\n};\n\n// TODO: If we are doing predicates, there is no point in pursuing\n//     closure operations if we reach a DFA state that uniquely predicts\n//     alternative. We will not be caching that DFA state and it is a\n//     waste to pursue the closure. Might have to advance when we do\n//     ambig detection thought :(\n//\n\nParserATNSimulator.prototype.closure = function(config, configs, closureBusy, collectPredicates, fullCtx, treatEofAsEpsilon) {\n    var initialDepth = 0;\n    this.closureCheckingStopState(config, configs, closureBusy, collectPredicates,\n                             fullCtx, initialDepth, treatEofAsEpsilon);\n};\n\n\nParserATNSimulator.prototype.closureCheckingStopState = function(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {\n    if (this.debug) {\n        console.log(\"closure(\" + config.toString(this.parser,true) + \")\");\n        console.log(\"configs(\" + configs.toString() + \")\");\n        if(config.reachesIntoOuterContext>50) {\n            throw \"problem\";\n        }\n    }\n    if (config.state instanceof RuleStopState) {\n        // We hit rule end. If we have context info, use it\n        // run thru all possible stack tops in ctx\n        if (! config.context.isEmpty()) {\n            for ( var i =0; i<config.context.length; i++) {\n                if (config.context.getReturnState(i) === PredictionContext.EMPTY_RETURN_STATE) {\n                    if (fullCtx) {\n                        configs.add(new ATNConfig({state:config.state, context:PredictionContext.EMPTY}, config), this.mergeCache);\n                        continue;\n                    } else {\n                        // we have no context info, just chase follow links (if greedy)\n                        if (this.debug) {\n                            console.log(\"FALLING off rule \" + this.getRuleName(config.state.ruleIndex));\n                        }\n                        this.closure_(config, configs, closureBusy, collectPredicates,\n                                 fullCtx, depth, treatEofAsEpsilon);\n                    }\n                    continue;\n                }\n                var returnState = this.atn.states[config.context.getReturnState(i)];\n                var newContext = config.context.getParent(i); // \"pop\" return state\n                var parms = {state:returnState, alt:config.alt, context:newContext, semanticContext:config.semanticContext};\n                var c = new ATNConfig(parms, null);\n                // While we have context to pop back from, we may have\n                // gotten that context AFTER having falling off a rule.\n                // Make sure we track that we are now out of context.\n                c.reachesIntoOuterContext = config.reachesIntoOuterContext;\n                this.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon);\n            }\n            return;\n        } else if( fullCtx) {\n            // reached end of start rule\n            configs.add(config, this.mergeCache);\n            return;\n        } else {\n            // else if we have no context info, just chase follow links (if greedy)\n            if (this.debug) {\n                console.log(\"FALLING off rule \" + this.getRuleName(config.state.ruleIndex));\n            }\n        }\n    }\n    this.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon);\n};\n\n// Do the actual work of walking epsilon edges//\nParserATNSimulator.prototype.closure_ = function(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon) {\n    var p = config.state;\n    // optimization\n    if (! p.epsilonOnlyTransitions) {\n        configs.add(config, this.mergeCache);\n        // make sure to not return here, because EOF transitions can act as\n        // both epsilon transitions and non-epsilon transitions.\n    }\n    for(var i = 0;i<p.transitions.length; i++) {\n        var t = p.transitions[i];\n        var continueCollecting = collectPredicates && !(t instanceof ActionTransition);\n        var c = this.getEpsilonTarget(config, t, continueCollecting, depth === 0, fullCtx, treatEofAsEpsilon);\n        if (c!==null) {\n\t\t\tif (!t.isEpsilon && closureBusy.add(c)!==c){\n\t\t\t\t// avoid infinite recursion for EOF* and EOF+\n\t\t\t\tcontinue;\n\t\t\t}\n            var newDepth = depth;\n            if ( config.state instanceof RuleStopState) {\n                // target fell off end of rule; mark resulting c as having dipped into outer context\n                // We can't get here if incoming config was rule stop and we had context\n                // track how far we dip into outer context.  Might\n                // come in handy and we avoid evaluating context dependent\n                // preds if this is > 0.\n\n                if (closureBusy.add(c)!==c) {\n                    // avoid infinite recursion for right-recursive rules\n                    continue;\n                }\n\n\t\t\t\tif (this._dfa !== null && this._dfa.precedenceDfa) {\n\t\t\t\t\tif (t.outermostPrecedenceReturn === this._dfa.atnStartState.ruleIndex) {\n\t\t\t\t\t\tc.precedenceFilterSuppressed = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\n                c.reachesIntoOuterContext += 1;\n                configs.dipsIntoOuterContext = true; // TODO: can remove? only care when we add to set per middle of this method\n                newDepth -= 1;\n                if (this.debug) {\n                    console.log(\"dips into outer ctx: \" + c);\n                }\n            } else if (t instanceof RuleTransition) {\n                // latch when newDepth goes negative - once we step out of the entry context we can't return\n                if (newDepth >= 0) {\n                    newDepth += 1;\n                }\n            }\n            this.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon);\n        }\n    }\n};\n\nParserATNSimulator.prototype.getRuleName = function( index) {\n    if (this.parser!==null && index>=0) {\n        return this.parser.ruleNames[index];\n    } else {\n        return \"<rule \" + index + \">\";\n    }\n};\n\nParserATNSimulator.prototype.getEpsilonTarget = function(config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon) {\n    switch(t.serializationType) {\n    case Transition.RULE:\n        return this.ruleTransition(config, t);\n    case Transition.PRECEDENCE:\n        return this.precedenceTransition(config, t, collectPredicates, inContext, fullCtx);\n    case Transition.PREDICATE:\n        return this.predTransition(config, t, collectPredicates, inContext, fullCtx);\n    case Transition.ACTION:\n        return this.actionTransition(config, t);\n    case Transition.EPSILON:\n        return new ATNConfig({state:t.target}, config);\n    case Transition.ATOM:\n    case Transition.RANGE:\n    case Transition.SET:\n        // EOF transitions act like epsilon transitions after the first EOF\n        // transition is traversed\n        if (treatEofAsEpsilon) {\n            if (t.matches(Token.EOF, 0, 1)) {\n                return new ATNConfig({state: t.target}, config);\n            }\n        }\n        return null;\n    default:\n    \treturn null;\n    }\n};\n\nParserATNSimulator.prototype.actionTransition = function(config, t) {\n    if (this.debug) {\n        console.log(\"ACTION edge \" + t.ruleIndex + \":\" + t.actionIndex);\n    }\n    return new ATNConfig({state:t.target}, config);\n};\n\nParserATNSimulator.prototype.precedenceTransition = function(config, pt,  collectPredicates, inContext, fullCtx) {\n    if (this.debug) {\n        console.log(\"PRED (collectPredicates=\" + collectPredicates + \") \" +\n                pt.precedence + \">=_p, ctx dependent=true\");\n        if (this.parser!==null) {\n        \tconsole.log(\"context surrounding pred is \" + Utils.arrayToString(this.parser.getRuleInvocationStack()));\n        }\n    }\n    var c = null;\n    if (collectPredicates && inContext) {\n        if (fullCtx) {\n            // In full context mode, we can evaluate predicates on-the-fly\n            // during closure, which dramatically reduces the size of\n            // the config sets. It also obviates the need to test predicates\n            // later during conflict resolution.\n            var currentPosition = this._input.index;\n            this._input.seek(this._startIndex);\n            var predSucceeds = pt.getPredicate().evaluate(this.parser, this._outerContext);\n            this._input.seek(currentPosition);\n            if (predSucceeds) {\n                c = new ATNConfig({state:pt.target}, config); // no pred context\n            }\n        } else {\n            newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());\n            c = new ATNConfig({state:pt.target, semanticContext:newSemCtx}, config);\n        }\n    } else {\n        c = new ATNConfig({state:pt.target}, config);\n    }\n    if (this.debug) {\n        console.log(\"config from pred transition=\" + c);\n    }\n    return c;\n};\n\nParserATNSimulator.prototype.predTransition = function(config, pt, collectPredicates, inContext, fullCtx) {\n    if (this.debug) {\n        console.log(\"PRED (collectPredicates=\" + collectPredicates + \") \" + pt.ruleIndex +\n                \":\" + pt.predIndex + \", ctx dependent=\" + pt.isCtxDependent);\n        if (this.parser!==null) {\n            console.log(\"context surrounding pred is \" + Utils.arrayToString(this.parser.getRuleInvocationStack()));\n        }\n    }\n    var c = null;\n    if (collectPredicates && ((pt.isCtxDependent && inContext) || ! pt.isCtxDependent)) {\n        if (fullCtx) {\n            // In full context mode, we can evaluate predicates on-the-fly\n            // during closure, which dramatically reduces the size of\n            // the config sets. It also obviates the need to test predicates\n            // later during conflict resolution.\n            var currentPosition = this._input.index;\n            this._input.seek(this._startIndex);\n            var predSucceeds = pt.getPredicate().evaluate(this.parser, this._outerContext);\n            this._input.seek(currentPosition);\n            if (predSucceeds) {\n                c = new ATNConfig({state:pt.target}, config); // no pred context\n            }\n        } else {\n            var newSemCtx = SemanticContext.andContext(config.semanticContext, pt.getPredicate());\n            c = new ATNConfig({state:pt.target, semanticContext:newSemCtx}, config);\n        }\n    } else {\n        c = new ATNConfig({state:pt.target}, config);\n    }\n    if (this.debug) {\n        console.log(\"config from pred transition=\" + c);\n    }\n    return c;\n};\n\nParserATNSimulator.prototype.ruleTransition = function(config, t) {\n    if (this.debug) {\n        console.log(\"CALL rule \" + this.getRuleName(t.target.ruleIndex) + \", ctx=\" + config.context);\n    }\n    var returnState = t.followState;\n    var newContext = SingletonPredictionContext.create(config.context, returnState.stateNumber);\n    return new ATNConfig({state:t.target, context:newContext}, config );\n};\n\nParserATNSimulator.prototype.getConflictingAlts = function(configs) {\n    var altsets = PredictionMode.getConflictingAltSubsets(configs);\n    return PredictionMode.getAlts(altsets);\n};\n\n // Sam pointed out a problem with the previous definition, v3, of\n // ambiguous states. If we have another state associated with conflicting\n // alternatives, we should keep going. For example, the following grammar\n //\n // s : (ID | ID ID?) ';' ;\n //\n // When the ATN simulation reaches the state before ';', it has a DFA\n // state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally\n // 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node\n // because alternative to has another way to continue, via [6|2|[]].\n // The key is that we have a single state that has config's only associated\n // with a single alternative, 2, and crucially the state transitions\n // among the configurations are all non-epsilon transitions. That means\n // we don't consider any conflicts that include alternative 2. So, we\n // ignore the conflict between alts 1 and 2. We ignore a set of\n // conflicting alts when there is an intersection with an alternative\n // associated with a single alt state in the state&rarr;config-list map.\n //\n // It's also the case that we might have two conflicting configurations but\n // also a 3rd nonconflicting configuration for a different alternative:\n // [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:\n //\n // a : A | A | A B ;\n //\n // After matching input A, we reach the stop state for rule A, state 1.\n // State 8 is the state right before B. Clearly alternatives 1 and 2\n // conflict and no amount of further lookahead will separate the two.\n // However, alternative 3 will be able to continue and so we do not\n // stop working on this state. In the previous example, we're concerned\n // with states associated with the conflicting alternatives. Here alt\n // 3 is not associated with the conflicting configs, but since we can continue\n // looking for input reasonably, I don't declare the state done. We\n // ignore a set of conflicting alts when we have an alternative\n // that we still need to pursue.\n//\n\nParserATNSimulator.prototype.getConflictingAltsOrUniqueAlt = function(configs) {\n    var conflictingAlts = null;\n    if (configs.uniqueAlt!== ATN.INVALID_ALT_NUMBER) {\n        conflictingAlts = new BitSet();\n        conflictingAlts.add(configs.uniqueAlt);\n    } else {\n        conflictingAlts = configs.conflictingAlts;\n    }\n    return conflictingAlts;\n};\n\nParserATNSimulator.prototype.getTokenName = function( t) {\n    if (t===Token.EOF) {\n        return \"EOF\";\n    }\n    if( this.parser!==null && this.parser.literalNames!==null) {\n        if (t >= this.parser.literalNames.length) {\n            console.log(\"\" + t + \" ttype out of range: \" + this.parser.literalNames);\n            console.log(\"\" + this.parser.getInputStream().getTokens());\n        } else {\n            return this.parser.literalNames[t] + \"<\" + t + \">\";\n        }\n    }\n    return \"\" + t;\n};\n\nParserATNSimulator.prototype.getLookaheadName = function(input) {\n    return this.getTokenName(input.LA(1));\n};\n\n// Used for debugging in adaptivePredict around execATN but I cut\n//  it out for clarity now that alg. works well. We can leave this\n//  \"dead\" code for a bit.\n//\nParserATNSimulator.prototype.dumpDeadEndConfigs = function(nvae) {\n    console.log(\"dead end configs: \");\n    var decs = nvae.getDeadEndConfigs();\n    for(var i=0; i<decs.length; i++) {\n    \tvar c = decs[i];\n        var trans = \"no edges\";\n        if (c.state.transitions.length>0) {\n            var t = c.state.transitions[0];\n            if (t instanceof AtomTransition) {\n                trans = \"Atom \"+ this.getTokenName(t.label);\n            } else if (t instanceof SetTransition) {\n                var neg = (t instanceof NotSetTransition);\n                trans = (neg ? \"~\" : \"\") + \"Set \" + t.set;\n            }\n        }\n        console.error(c.toString(this.parser, true) + \":\" + trans);\n    }\n};\n\nParserATNSimulator.prototype.noViableAlt = function(input, outerContext, configs, startIndex) {\n    return new NoViableAltException(this.parser, input, input.get(startIndex), input.LT(1), configs, outerContext);\n};\n\nParserATNSimulator.prototype.getUniqueAlt = function(configs) {\n    var alt = ATN.INVALID_ALT_NUMBER;\n    for(var i=0;i<configs.items.length;i++) {\n    \tvar c = configs.items[i];\n        if (alt === ATN.INVALID_ALT_NUMBER) {\n            alt = c.alt // found first alt\n        } else if( c.alt!==alt) {\n            return ATN.INVALID_ALT_NUMBER;\n        }\n    }\n    return alt;\n};\n\n//\n// Add an edge to the DFA, if possible. This method calls\n// {@link //addDFAState} to ensure the {@code to} state is present in the\n// DFA. If {@code from} is {@code null}, or if {@code t} is outside the\n// range of edges that can be represented in the DFA tables, this method\n// returns without adding the edge to the DFA.\n//\n// <p>If {@code to} is {@code null}, this method returns {@code null}.\n// Otherwise, this method returns the {@link DFAState} returned by calling\n// {@link //addDFAState} for the {@code to} state.</p>\n//\n// @param dfa The DFA\n// @param from The source state for the edge\n// @param t The input symbol\n// @param to The target state for the edge\n//\n// @return If {@code to} is {@code null}, this method returns {@code null};\n// otherwise this method returns the result of calling {@link //addDFAState}\n// on {@code to}\n//\nParserATNSimulator.prototype.addDFAEdge = function(dfa, from_, t, to) {\n    if( this.debug) {\n        console.log(\"EDGE \" + from_ + \" -> \" + to + \" upon \" + this.getTokenName(t));\n    }\n    if (to===null) {\n        return null;\n    }\n    to = this.addDFAState(dfa, to); // used existing if possible not incoming\n    if (from_===null || t < -1 || t > this.atn.maxTokenType) {\n        return to;\n    }\n    if (from_.edges===null) {\n        from_.edges = [];\n    }\n    from_.edges[t+1] = to; // connect\n\n    if (this.debug) {\n        var names = this.parser===null ? null : this.parser.literalNames;\n        console.log(\"DFA=\\n\" + dfa.toString(names));\n    }\n    return to;\n};\n//\n// Add state {@code D} to the DFA if it is not already present, and return\n// the actual instance stored in the DFA. If a state equivalent to {@code D}\n// is already in the DFA, the existing state is returned. Otherwise this\n// method returns {@code D} after adding it to the DFA.\n//\n// <p>If {@code D} is {@link //ERROR}, this method returns {@link //ERROR} and\n// does not change the DFA.</p>\n//\n// @param dfa The dfa\n// @param D The DFA state to add\n// @return The state stored in the DFA. This will be either the existing\n// state if {@code D} is already in the DFA, or {@code D} itself if the\n// state was not already present.\n//\nParserATNSimulator.prototype.addDFAState = function(dfa, D) {\n    if (D == ATNSimulator.ERROR) {\n        return D;\n    }\n    var hash = D.hashString();\n    var existing = dfa.states[hash] || null;\n    if(existing!==null) {\n        return existing;\n    }\n    D.stateNumber = dfa.states.length;\n    if (! D.configs.readOnly) {\n        D.configs.optimizeConfigs(this);\n        D.configs.setReadonly(true);\n    }\n    dfa.states[hash] = D;\n    if (this.debug) {\n        console.log(\"adding new DFA state: \" + D);\n    }\n    return D;\n};\n\nParserATNSimulator.prototype.reportAttemptingFullContext = function(dfa, conflictingAlts, configs, startIndex, stopIndex) {\n    if (this.debug || this.retry_debug) {\n        var interval = new Interval(startIndex, stopIndex + 1);\n        console.log(\"reportAttemptingFullContext decision=\" + dfa.decision + \":\" + configs +\n                           \", input=\" + this.parser.getTokenStream().getText(interval));\n    }\n    if (this.parser!==null) {\n        this.parser.getErrorListenerDispatch().reportAttemptingFullContext(this.parser, dfa, startIndex, stopIndex, conflictingAlts, configs);\n    }\n};\n\nParserATNSimulator.prototype.reportContextSensitivity = function(dfa, prediction, configs, startIndex, stopIndex) {\n    if (this.debug || this.retry_debug) {\n        var interval = new Interval(startIndex, stopIndex + 1);\n        console.log(\"reportContextSensitivity decision=\" + dfa.decision + \":\" + configs +\n                           \", input=\" + this.parser.getTokenStream().getText(interval));\n    }\n    if (this.parser!==null) {\n        this.parser.getErrorListenerDispatch().reportContextSensitivity(this.parser, dfa, startIndex, stopIndex, prediction, configs);\n    }\n};\n    \n// If context sensitive parsing, we know it's ambiguity not conflict//\nParserATNSimulator.prototype.reportAmbiguity = function(dfa, D, startIndex, stopIndex,\n                               exact, ambigAlts, configs ) {\n    if (this.debug || this.retry_debug) {\n        var interval = new Interval(startIndex, stopIndex + 1);\n        console.log(\"reportAmbiguity \" + ambigAlts + \":\" + configs +\n                           \", input=\" + this.parser.getTokenStream().getText(interval));\n    }\n    if (this.parser!==null) {\n        this.parser.getErrorListenerDispatch().reportAmbiguity(this.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs);\n    }\n};\n            \nexports.ParserATNSimulator = ParserATNSimulator;\n},{\"./../IntervalSet\":6,\"./../ParserRuleContext\":10,\"./../PredictionContext\":11,\"./../RuleContext\":13,\"./../Token\":14,\"./../Utils\":15,\"./../dfa/DFAState\":34,\"./../error/Errors\":39,\"./ATN\":16,\"./ATNConfig\":17,\"./ATNConfigSet\":18,\"./ATNSimulator\":21,\"./ATNState\":22,\"./PredictionMode\":28,\"./SemanticContext\":29,\"./Transition\":30}],28:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n//\n// This enumeration defines the prediction modes available in ANTLR 4 along with\n// utility methods for analyzing configuration sets for conflicts and/or\n// ambiguities.\n\nvar Set = require('./../Utils').Set;\nvar BitSet = require('./../Utils').BitSet;\nvar AltDict = require('./../Utils').AltDict;\nvar ATN = require('./ATN').ATN;\nvar RuleStopState = require('./ATNState').RuleStopState;\nvar ATNConfigSet = require('./ATNConfigSet').ATNConfigSet;\nvar ATNConfig = require('./ATNConfig').ATNConfig;\nvar SemanticContext = require('./SemanticContext').SemanticContext;\n\nfunction PredictionMode() {\n\treturn this;\n}\n\n//\n// The SLL(*) prediction mode. This prediction mode ignores the current\n// parser context when making predictions. This is the fastest prediction\n// mode, and provides correct results for many grammars. This prediction\n// mode is more powerful than the prediction mode provided by ANTLR 3, but\n// may result in syntax errors for grammar and input combinations which are\n// not SLL.\n//\n// <p>\n// When using this prediction mode, the parser will either return a correct\n// parse tree (i.e. the same parse tree that would be returned with the\n// {@link //LL} prediction mode), or it will report a syntax error. If a\n// syntax error is encountered when using the {@link //SLL} prediction mode,\n// it may be due to either an actual syntax error in the input or indicate\n// that the particular combination of grammar and input requires the more\n// powerful {@link //LL} prediction abilities to complete successfully.</p>\n//\n// <p>\n// This prediction mode does not provide any guarantees for prediction\n// behavior for syntactically-incorrect inputs.</p>\n//\nPredictionMode.SLL = 0;\n//\n// The LL(*) prediction mode. This prediction mode allows the current parser\n// context to be used for resolving SLL conflicts that occur during\n// prediction. This is the fastest prediction mode that guarantees correct\n// parse results for all combinations of grammars with syntactically correct\n// inputs.\n//\n// <p>\n// When using this prediction mode, the parser will make correct decisions\n// for all syntactically-correct grammar and input combinations. However, in\n// cases where the grammar is truly ambiguous this prediction mode might not\n// report a precise answer for <em>exactly which</em> alternatives are\n// ambiguous.</p>\n//\n// <p>\n// This prediction mode does not provide any guarantees for prediction\n// behavior for syntactically-incorrect inputs.</p>\n//\nPredictionMode.LL = 1;\n//\n// The LL(*) prediction mode with exact ambiguity detection. In addition to\n// the correctness guarantees provided by the {@link //LL} prediction mode,\n// this prediction mode instructs the prediction algorithm to determine the\n// complete and exact set of ambiguous alternatives for every ambiguous\n// decision encountered while parsing.\n//\n// <p>\n// This prediction mode may be used for diagnosing ambiguities during\n// grammar development. Due to the performance overhead of calculating sets\n// of ambiguous alternatives, this prediction mode should be avoided when\n// the exact results are not necessary.</p>\n//\n// <p>\n// This prediction mode does not provide any guarantees for prediction\n// behavior for syntactically-incorrect inputs.</p>\n//\nPredictionMode.LL_EXACT_AMBIG_DETECTION = 2;\n\n\n//\n// Computes the SLL prediction termination condition.\n//\n// <p>\n// This method computes the SLL prediction termination condition for both of\n// the following cases.</p>\n//\n// <ul>\n// <li>The usual SLL+LL fallback upon SLL conflict</li>\n// <li>Pure SLL without LL fallback</li>\n// </ul>\n//\n// <p><strong>COMBINED SLL+LL PARSING</strong></p>\n//\n// <p>When LL-fallback is enabled upon SLL conflict, correct predictions are\n// ensured regardless of how the termination condition is computed by this\n// method. Due to the substantially higher cost of LL prediction, the\n// prediction should only fall back to LL when the additional lookahead\n// cannot lead to a unique SLL prediction.</p>\n//\n// <p>Assuming combined SLL+LL parsing, an SLL configuration set with only\n// conflicting subsets should fall back to full LL, even if the\n// configuration sets don't resolve to the same alternative (e.g.\n// {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting\n// configuration, SLL could continue with the hopes that more lookahead will\n// resolve via one of those non-conflicting configurations.</p>\n//\n// <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)\n// stops when it sees only conflicting configuration subsets. In contrast,\n// full LL keeps going when there is uncertainty.</p>\n//\n// <p><strong>HEURISTIC</strong></p>\n//\n// <p>As a heuristic, we stop prediction when we see any conflicting subset\n// unless we see a state that only has one alternative associated with it.\n// The single-alt-state thing lets prediction continue upon rules like\n// (otherwise, it would admit defeat too soon):</p>\n//\n// <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>\n//\n// <p>When the ATN simulation reaches the state before {@code ';'}, it has a\n// DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally\n// {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop\n// processing this node because alternative to has another way to continue,\n// via {@code [6|2|[]]}.</p>\n//\n// <p>It also let's us continue for this rule:</p>\n//\n// <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>\n//\n// <p>After matching input A, we reach the stop state for rule A, state 1.\n// State 8 is the state right before B. Clearly alternatives 1 and 2\n// conflict and no amount of further lookahead will separate the two.\n// However, alternative 3 will be able to continue and so we do not stop\n// working on this state. In the previous example, we're concerned with\n// states associated with the conflicting alternatives. Here alt 3 is not\n// associated with the conflicting configs, but since we can continue\n// looking for input reasonably, don't declare the state done.</p>\n//\n// <p><strong>PURE SLL PARSING</strong></p>\n//\n// <p>To handle pure SLL parsing, all we have to do is make sure that we\n// combine stack contexts for configurations that differ only by semantic\n// predicate. From there, we can do the usual SLL termination heuristic.</p>\n//\n// <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>\n//\n// <p>SLL decisions don't evaluate predicates until after they reach DFA stop\n// states because they need to create the DFA cache that works in all\n// semantic situations. In contrast, full LL evaluates predicates collected\n// during start state computation so it can ignore predicates thereafter.\n// This means that SLL termination detection can totally ignore semantic\n// predicates.</p>\n//\n// <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not\n// semantic predicate contexts so we might see two configurations like the\n// following.</p>\n//\n// <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>\n//\n// <p>Before testing these configurations against others, we have to merge\n// {@code x} and {@code x'} (without modifying the existing configurations).\n// For example, we test {@code (x+x')==x''} when looking for conflicts in\n// the following configurations.</p>\n//\n// <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>\n//\n// <p>If the configuration set has predicates (as indicated by\n// {@link ATNConfigSet//hasSemanticContext}), this algorithm makes a copy of\n// the configurations to strip out all of the predicates so that a standard\n// {@link ATNConfigSet} will merge everything ignoring predicates.</p>\n//\nPredictionMode.hasSLLConflictTerminatingPrediction = function( mode, configs) {\n    // Configs in rule stop states indicate reaching the end of the decision\n    // rule (local context) or end of start rule (full context). If all\n    // configs meet this condition, then none of the configurations is able\n    // to match additional input so we terminate prediction.\n    //\n    if (PredictionMode.allConfigsInRuleStopStates(configs)) {\n        return true;\n    }\n    // pure SLL mode parsing\n    if (mode === PredictionMode.SLL) {\n        // Don't bother with combining configs from different semantic\n        // contexts if we can fail over to full LL; costs more time\n        // since we'll often fail over anyway.\n        if (configs.hasSemanticContext) {\n            // dup configs, tossing out semantic predicates\n            var dup = new ATNConfigSet();\n            for(var i=0;i<configs.items.length;i++) {\n            \tvar c = configs.items[i];\n                c = new ATNConfig({semanticContext:SemanticContext.NONE}, c);\n                dup.add(c);\n            }\n            configs = dup;\n        }\n        // now we have combined contexts for configs with dissimilar preds\n    }\n    // pure SLL or combined SLL+LL mode parsing\n    var altsets = PredictionMode.getConflictingAltSubsets(configs);\n    return PredictionMode.hasConflictingAltSet(altsets) && !PredictionMode.hasStateAssociatedWithOneAlt(configs);\n};\n\n// Checks if any configuration in {@code configs} is in a\n// {@link RuleStopState}. Configurations meeting this condition have reached\n// the end of the decision rule (local context) or end of start rule (full\n// context).\n//\n// @param configs the configuration set to test\n// @return {@code true} if any configuration in {@code configs} is in a\n// {@link RuleStopState}, otherwise {@code false}\nPredictionMode.hasConfigInRuleStopState = function(configs) {\n\tfor(var i=0;i<configs.items.length;i++) {\n\t\tvar c = configs.items[i];\n        if (c.state instanceof RuleStopState) {\n            return true;\n        }\n\t}\n    return false;\n};\n\n// Checks if all configurations in {@code configs} are in a\n// {@link RuleStopState}. Configurations meeting this condition have reached\n// the end of the decision rule (local context) or end of start rule (full\n// context).\n//\n// @param configs the configuration set to test\n// @return {@code true} if all configurations in {@code configs} are in a\n// {@link RuleStopState}, otherwise {@code false}\nPredictionMode.allConfigsInRuleStopStates = function(configs) {\n\tfor(var i=0;i<configs.items.length;i++) {\n\t\tvar c = configs.items[i];\n        if (!(c.state instanceof RuleStopState)) {\n            return false;\n        }\n\t}\n    return true;\n};\n\n//\n// Full LL prediction termination.\n//\n// <p>Can we stop looking ahead during ATN simulation or is there some\n// uncertainty as to which alternative we will ultimately pick, after\n// consuming more input? Even if there are partial conflicts, we might know\n// that everything is going to resolve to the same minimum alternative. That\n// means we can stop since no more lookahead will change that fact. On the\n// other hand, there might be multiple conflicts that resolve to different\n// minimums. That means we need more look ahead to decide which of those\n// alternatives we should predict.</p>\n//\n// <p>The basic idea is to split the set of configurations {@code C}, into\n// conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with\n// non-conflicting configurations. Two configurations conflict if they have\n// identical {@link ATNConfig//state} and {@link ATNConfig//context} values\n// but different {@link ATNConfig//alt} value, e.g. {@code (s, i, ctx, _)}\n// and {@code (s, j, ctx, _)} for {@code i!=j}.</p>\n//\n// <p>Reduce these configuration subsets to the set of possible alternatives.\n// You can compute the alternative subsets in one pass as follows:</p>\n//\n// <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in\n// {@code C} holding {@code s} and {@code ctx} fixed.</p>\n//\n// <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>\n//\n// <pre>\n// map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not\n// alt and not pred\n// </pre>\n//\n// <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>\n//\n// <p>If {@code |A_s,ctx|=1} then there is no conflict associated with\n// {@code s} and {@code ctx}.</p>\n//\n// <p>Reduce the subsets to singletons by choosing a minimum of each subset. If\n// the union of these alternative subsets is a singleton, then no amount of\n// more lookahead will help us. We will always pick that alternative. If,\n// however, there is more than one alternative, then we are uncertain which\n// alternative to predict and must continue looking for resolution. We may\n// or may not discover an ambiguity in the future, even if there are no\n// conflicting subsets this round.</p>\n//\n// <p>The biggest sin is to terminate early because it means we've made a\n// decision but were uncertain as to the eventual outcome. We haven't used\n// enough lookahead. On the other hand, announcing a conflict too late is no\n// big deal; you will still have the conflict. It's just inefficient. It\n// might even look until the end of file.</p>\n//\n// <p>No special consideration for semantic predicates is required because\n// predicates are evaluated on-the-fly for full LL prediction, ensuring that\n// no configuration contains a semantic context during the termination\n// check.</p>\n//\n// <p><strong>CONFLICTING CONFIGS</strong></p>\n//\n// <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict\n// when {@code i!=j} but {@code x=x'}. Because we merge all\n// {@code (s, i, _)} configurations together, that means that there are at\n// most {@code n} configurations associated with state {@code s} for\n// {@code n} possible alternatives in the decision. The merged stacks\n// complicate the comparison of configuration contexts {@code x} and\n// {@code x'}. Sam checks to see if one is a subset of the other by calling\n// merge and checking to see if the merged result is either {@code x} or\n// {@code x'}. If the {@code x} associated with lowest alternative {@code i}\n// is the superset, then {@code i} is the only possible prediction since the\n// others resolve to {@code min(i)} as well. However, if {@code x} is\n// associated with {@code j>i} then at least one stack configuration for\n// {@code j} is not in conflict with alternative {@code i}. The algorithm\n// should keep going, looking for more lookahead due to the uncertainty.</p>\n//\n// <p>For simplicity, I'm doing a equality check between {@code x} and\n// {@code x'} that lets the algorithm continue to consume lookahead longer\n// than necessary. The reason I like the equality is of course the\n// simplicity but also because that is the test you need to detect the\n// alternatives that are actually in conflict.</p>\n//\n// <p><strong>CONTINUE/STOP RULE</strong></p>\n//\n// <p>Continue if union of resolved alternative sets from non-conflicting and\n// conflicting alternative subsets has more than one alternative. We are\n// uncertain about which alternative to predict.</p>\n//\n// <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which\n// alternatives are still in the running for the amount of input we've\n// consumed at this point. The conflicting sets let us to strip away\n// configurations that won't lead to more states because we resolve\n// conflicts to the configuration with a minimum alternate for the\n// conflicting set.</p>\n//\n// <p><strong>CASES</strong></p>\n//\n// <ul>\n//\n// <li>no conflicts and more than 1 alternative in set =&gt; continue</li>\n//\n// <li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)},\n// {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set\n// {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =\n// {@code {1,3}} =&gt; continue\n// </li>\n//\n// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},\n// {@code (s', 2, y)}, {@code (s'', 1, z)} yields non-conflicting set\n// {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =\n// {@code {1}} =&gt; stop and predict 1</li>\n//\n// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},\n// {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U\n// {@code {1}} = {@code {1}} =&gt; stop and predict 1, can announce\n// ambiguity {@code {1,2}}</li>\n//\n// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)},\n// {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U\n// {@code {2}} = {@code {1,2}} =&gt; continue</li>\n//\n// <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)},\n// {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U\n// {@code {3}} = {@code {1,3}} =&gt; continue</li>\n//\n// </ul>\n//\n// <p><strong>EXACT AMBIGUITY DETECTION</strong></p>\n//\n// <p>If all states report the same conflicting set of alternatives, then we\n// know we have the exact ambiguity set.</p>\n//\n// <p><code>|A_<em>i</em>|&gt;1</code> and\n// <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>\n//\n// <p>In other words, we continue examining lookahead until all {@code A_i}\n// have more than one alternative and all {@code A_i} are the same. If\n// {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate\n// because the resolved set is {@code {1}}. To determine what the real\n// ambiguity is, we have to know whether the ambiguity is between one and\n// two or one and three so we keep going. We can only stop prediction when\n// we need exact ambiguity detection when the sets look like\n// {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>\n//\nPredictionMode.resolvesToJustOneViableAlt = function(altsets) {\n    return PredictionMode.getSingleViableAlt(altsets);\n};\n\n//\n// Determines if every alternative subset in {@code altsets} contains more\n// than one alternative.\n//\n// @param altsets a collection of alternative subsets\n// @return {@code true} if every {@link BitSet} in {@code altsets} has\n// {@link BitSet//cardinality cardinality} &gt; 1, otherwise {@code false}\n//\nPredictionMode.allSubsetsConflict = function(altsets) {\n    return ! PredictionMode.hasNonConflictingAltSet(altsets);\n};\n//\n// Determines if any single alternative subset in {@code altsets} contains\n// exactly one alternative.\n//\n// @param altsets a collection of alternative subsets\n// @return {@code true} if {@code altsets} contains a {@link BitSet} with\n// {@link BitSet//cardinality cardinality} 1, otherwise {@code false}\n//\nPredictionMode.hasNonConflictingAltSet = function(altsets) {\n\tfor(var i=0;i<altsets.length;i++) {\n\t\tvar alts = altsets[i];\n        if (alts.length===1) {\n            return true;\n        }\n\t}\n    return false;\n};\n\n//\n// Determines if any single alternative subset in {@code altsets} contains\n// more than one alternative.\n//\n// @param altsets a collection of alternative subsets\n// @return {@code true} if {@code altsets} contains a {@link BitSet} with\n// {@link BitSet//cardinality cardinality} &gt; 1, otherwise {@code false}\n//\nPredictionMode.hasConflictingAltSet = function(altsets) {\n\tfor(var i=0;i<altsets.length;i++) {\n\t\tvar alts = altsets[i];\n        if (alts.length>1) {\n            return true;\n        }\n\t}\n    return false;\n};\n\n//\n// Determines if every alternative subset in {@code altsets} is equivalent.\n//\n// @param altsets a collection of alternative subsets\n// @return {@code true} if every member of {@code altsets} is equal to the\n// others, otherwise {@code false}\n//\nPredictionMode.allSubsetsEqual = function(altsets) {\n    var first = null;\n\tfor(var i=0;i<altsets.length;i++) {\n\t\tvar alts = altsets[i];\n        if (first === null) {\n            first = alts;\n        } else if (alts!==first) {\n            return false;\n        }\n\t}\n    return true;\n};\n\n//\n// Returns the unique alternative predicted by all alternative subsets in\n// {@code altsets}. If no such alternative exists, this method returns\n// {@link ATN//INVALID_ALT_NUMBER}.\n//\n// @param altsets a collection of alternative subsets\n//\nPredictionMode.getUniqueAlt = function(altsets) {\n    var all = PredictionMode.getAlts(altsets);\n    if (all.length===1) {\n        return all.minValue();\n    } else {\n        return ATN.INVALID_ALT_NUMBER;\n    }\n};\n\n// Gets the complete set of represented alternatives for a collection of\n// alternative subsets. This method returns the union of each {@link BitSet}\n// in {@code altsets}.\n//\n// @param altsets a collection of alternative subsets\n// @return the set of represented alternatives in {@code altsets}\n//\nPredictionMode.getAlts = function(altsets) {\n    var all = new BitSet();\n    altsets.map( function(alts) { all.or(alts); });\n    return all;\n};\n\n//\n// This function gets the conflicting alt subsets from a configuration set.\n// For each configuration {@code c} in {@code configs}:\n//\n// <pre>\n// map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not\n// alt and not pred\n// </pre>\n//\nPredictionMode.getConflictingAltSubsets = function(configs) {\n    var configToAlts = {};\n\tfor(var i=0;i<configs.items.length;i++) {\n\t\tvar c = configs.items[i];\n        var key = \"key_\" + c.state.stateNumber + \"/\" + c.context;\n        var alts = configToAlts[key] || null;\n        if (alts === null) {\n            alts = new BitSet();\n            configToAlts[key] = alts;\n        }\n        alts.add(c.alt);\n\t}\n\tvar values = [];\n\tfor(var k in configToAlts) {\n\t\tif(k.indexOf(\"key_\")!==0) {\n\t\t\tcontinue;\n\t\t}\n\t\tvalues.push(configToAlts[k]);\n\t}\n    return values;\n};\n\n//\n// Get a map from state to alt subset from a configuration set. For each\n// configuration {@code c} in {@code configs}:\n//\n// <pre>\n// map[c.{@link ATNConfig//state state}] U= c.{@link ATNConfig//alt alt}\n// </pre>\n//\nPredictionMode.getStateToAltMap = function(configs) {\n    var m = new AltDict();\n    configs.items.map(function(c) {\n        var alts = m.get(c.state);\n        if (alts === null) {\n            alts = new BitSet();\n            m.put(c.state, alts);\n        }\n        alts.add(c.alt);\n    });\n    return m;\n};\n\nPredictionMode.hasStateAssociatedWithOneAlt = function(configs) {\n    var values = PredictionMode.getStateToAltMap(configs).values();\n    for(var i=0;i<values.length;i++) {\n        if (values[i].length===1) {\n            return true;\n        }\n    }\n    return false;\n};\n\nPredictionMode.getSingleViableAlt = function(altsets) {\n    var result = null;\n\tfor(var i=0;i<altsets.length;i++) {\n\t\tvar alts = altsets[i];\n        var minAlt = alts.minValue();\n        if(result===null) {\n            result = minAlt;\n        } else if(result!==minAlt) { // more than 1 viable alt\n            return ATN.INVALID_ALT_NUMBER;\n        }\n\t}\n    return result;\n};\n\nexports.PredictionMode = PredictionMode;\n\n},{\"./../Utils\":15,\"./ATN\":16,\"./ATNConfig\":17,\"./ATNConfigSet\":18,\"./ATNState\":22,\"./SemanticContext\":29}],29:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n// A tree structure used to record the semantic context in which\n//  an ATN configuration is valid.  It's either a single predicate,\n//  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.\n//\n//  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of\n//  {@link SemanticContext} within the scope of this outer class.</p>\n//\n\nvar Set = require('./../Utils').Set;\n\nfunction SemanticContext() {\n\treturn this;\n}\n\n// For context independent predicates, we evaluate them without a local\n// context (i.e., null context). That way, we can evaluate them without\n// having to create proper rule-specific context during prediction (as\n// opposed to the parser, which creates them naturally). In a practical\n// sense, this avoids a cast exception from RuleContext to myruleContext.\n//\n// <p>For context dependent predicates, we must pass in a local context so that\n// references such as $arg evaluate properly as _localctx.arg. We only\n// capture context dependent predicates in the context in which we begin\n// prediction, so we passed in the outer context here in case of context\n// dependent predicate evaluation.</p>\n//\nSemanticContext.prototype.evaluate = function(parser, outerContext) {\n};\n\n//\n// Evaluate the precedence predicates for the context and reduce the result.\n//\n// @param parser The parser instance.\n// @param outerContext The current parser context object.\n// @return The simplified semantic context after precedence predicates are\n// evaluated, which will be one of the following values.\n// <ul>\n// <li>{@link //NONE}: if the predicate simplifies to {@code true} after\n// precedence predicates are evaluated.</li>\n// <li>{@code null}: if the predicate simplifies to {@code false} after\n// precedence predicates are evaluated.</li>\n// <li>{@code this}: if the semantic context is not changed as a result of\n// precedence predicate evaluation.</li>\n// <li>A non-{@code null} {@link SemanticContext}: the new simplified\n// semantic context after precedence predicates are evaluated.</li>\n// </ul>\n//\nSemanticContext.prototype.evalPrecedence = function(parser, outerContext) {\n\treturn this;\n};\n\nSemanticContext.andContext = function(a, b) {\n\tif (a === null || a === SemanticContext.NONE) {\n\t\treturn b;\n\t}\n\tif (b === null || b === SemanticContext.NONE) {\n\t\treturn a;\n\t}\n\tvar result = new AND(a, b);\n\tif (result.opnds.length === 1) {\n\t\treturn result.opnds[0];\n\t} else {\n\t\treturn result;\n\t}\n};\n\nSemanticContext.orContext = function(a, b) {\n\tif (a === null) {\n\t\treturn b;\n\t}\n\tif (b === null) {\n\t\treturn a;\n\t}\n\tif (a === SemanticContext.NONE || b === SemanticContext.NONE) {\n\t\treturn SemanticContext.NONE;\n\t}\n\tvar result = new OR(a, b);\n\tif (result.opnds.length === 1) {\n\t\treturn result.opnds[0];\n\t} else {\n\t\treturn result;\n\t}\n};\n\nfunction Predicate(ruleIndex, predIndex, isCtxDependent) {\n\tSemanticContext.call(this);\n\tthis.ruleIndex = ruleIndex === undefined ? -1 : ruleIndex;\n\tthis.predIndex = predIndex === undefined ? -1 : predIndex;\n\tthis.isCtxDependent = isCtxDependent === undefined ? false : isCtxDependent; // e.g., $i ref in pred\n\treturn this;\n}\n\nPredicate.prototype = Object.create(SemanticContext.prototype);\nPredicate.prototype.constructor = Predicate;\n\n//The default {@link SemanticContext}, which is semantically equivalent to\n//a predicate of the form {@code {true}?}.\n//\nSemanticContext.NONE = new Predicate();\n\n\nPredicate.prototype.evaluate = function(parser, outerContext) {\n\tvar localctx = this.isCtxDependent ? outerContext : null;\n\treturn parser.sempred(localctx, this.ruleIndex, this.predIndex);\n};\n\nPredicate.prototype.hashString = function() {\n\treturn \"\" + this.ruleIndex + \"/\" + this.predIndex + \"/\" + this.isCtxDependent;\n};\n\nPredicate.prototype.equals = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof Predicate)) {\n\t\treturn false;\n\t} else {\n\t\treturn this.ruleIndex === other.ruleIndex &&\n\t\t\t\tthis.predIndex === other.predIndex &&\n\t\t\t\tthis.isCtxDependent === other.isCtxDependent;\n\t}\n};\n\nPredicate.prototype.toString = function() {\n\treturn \"{\" + this.ruleIndex + \":\" + this.predIndex + \"}?\";\n};\n\nfunction PrecedencePredicate(precedence) {\n\tSemanticContext.call(this);\n\tthis.precedence = precedence === undefined ? 0 : precedence;\n}\n\nPrecedencePredicate.prototype = Object.create(SemanticContext.prototype);\nPrecedencePredicate.prototype.constructor = PrecedencePredicate;\n\nPrecedencePredicate.prototype.evaluate = function(parser, outerContext) {\n\treturn parser.precpred(outerContext, this.precedence);\n};\n\nPrecedencePredicate.prototype.evalPrecedence = function(parser, outerContext) {\n\tif (parser.precpred(outerContext, this.precedence)) {\n\t\treturn SemanticContext.NONE;\n\t} else {\n\t\treturn null;\n\t}\n};\n\nPrecedencePredicate.prototype.compareTo = function(other) {\n\treturn this.precedence - other.precedence;\n};\n\nPrecedencePredicate.prototype.hashString = function() {\n\treturn \"31\";\n};\n\nPrecedencePredicate.prototype.equals = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof PrecedencePredicate)) {\n\t\treturn false;\n\t} else {\n\t\treturn this.precedence === other.precedence;\n\t}\n};\n\nPrecedencePredicate.prototype.toString = function() {\n\treturn \"{\"+this.precedence+\">=prec}?\";\n};\n\n\n\nPrecedencePredicate.filterPrecedencePredicates = function(set) {\n\tvar result = [];\n\tset.values().map( function(context) {\n\t\tif (context instanceof PrecedencePredicate) {\n\t\t\tresult.push(context);\n\t\t}\n\t});\n\treturn result;\n};\n\n\n// A semantic context which is true whenever none of the contained contexts\n// is false.\n//\nfunction AND(a, b) {\n\tSemanticContext.call(this);\n\tvar operands = new Set();\n\tif (a instanceof AND) {\n\t\ta.opnds.map(function(o) {\n\t\t\toperands.add(o);\n\t\t});\n\t} else {\n\t\toperands.add(a);\n\t}\n\tif (b instanceof AND) {\n\t\tb.opnds.map(function(o) {\n\t\t\toperands.add(o);\n\t\t});\n\t} else {\n\t\toperands.add(b);\n\t}\n\tvar precedencePredicates = PrecedencePredicate.filterPrecedencePredicates(operands);\n\tif (precedencePredicates.length > 0) {\n\t\t// interested in the transition with the lowest precedence\n\t\tvar reduced = null;\n\t\tprecedencePredicates.map( function(p) {\n\t\t\tif(reduced===null || p.precedence<reduced.precedence) {\n\t\t\t\treduced = p;\n\t\t\t}\n\t\t});\n\t\toperands.add(reduced);\n\t}\n\tthis.opnds = operands.values();\n\treturn this;\n}\n\nAND.prototype = Object.create(SemanticContext.prototype);\nAND.prototype.constructor = AND;\n\nAND.prototype.equals = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof AND)) {\n\t\treturn false;\n\t} else {\n\t\treturn this.opnds === other.opnds;\n\t}\n};\n\nAND.prototype.hashString = function() {\n\treturn \"\" + this.opnds + \"/AND\";\n};\n//\n// {@inheritDoc}\n//\n// <p>\n// The evaluation of predicates by this context is short-circuiting, but\n// unordered.</p>\n//\nAND.prototype.evaluate = function(parser, outerContext) {\n\tfor (var i = 0; i < this.opnds.length; i++) {\n\t\tif (!this.opnds[i].evaluate(parser, outerContext)) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n};\n\nAND.prototype.evalPrecedence = function(parser, outerContext) {\n\tvar differs = false;\n\tvar operands = [];\n\tfor (var i = 0; i < this.opnds.length; i++) {\n\t\tvar context = this.opnds[i];\n\t\tvar evaluated = context.evalPrecedence(parser, outerContext);\n\t\tdiffers |= (evaluated !== context);\n\t\tif (evaluated === null) {\n\t\t\t// The AND context is false if any element is false\n\t\t\treturn null;\n\t\t} else if (evaluated !== SemanticContext.NONE) {\n\t\t\t// Reduce the result by skipping true elements\n\t\t\toperands.push(evaluated);\n\t\t}\n\t}\n\tif (!differs) {\n\t\treturn this;\n\t}\n\tif (operands.length === 0) {\n\t\t// all elements were true, so the AND context is true\n\t\treturn SemanticContext.NONE;\n\t}\n\tvar result = null;\n\toperands.map(function(o) {\n\t\tresult = result === null ? o : SemanticContext.andContext(result, o);\n\t});\n\treturn result;\n};\n\nAND.prototype.toString = function() {\n\tvar s = \"\";\n\tthis.opnds.map(function(o) {\n\t\ts += \"&& \" + o.toString();\n\t});\n\treturn s.length > 3 ? s.slice(3) : s;\n};\n\n//\n// A semantic context which is true whenever at least one of the contained\n// contexts is true.\n//\nfunction OR(a, b) {\n\tSemanticContext.call(this);\n\tvar operands = new Set();\n\tif (a instanceof OR) {\n\t\ta.opnds.map(function(o) {\n\t\t\toperands.add(o);\n\t\t});\n\t} else {\n\t\toperands.add(a);\n\t}\n\tif (b instanceof OR) {\n\t\tb.opnds.map(function(o) {\n\t\t\toperands.add(o);\n\t\t});\n\t} else {\n\t\toperands.add(b);\n\t}\n\n\tvar precedencePredicates = PrecedencePredicate.filterPrecedencePredicates(operands);\n\tif (precedencePredicates.length > 0) {\n\t\t// interested in the transition with the highest precedence\n\t\tvar s = precedencePredicates.sort(function(a, b) {\n\t\t\treturn a.compareTo(b);\n\t\t});\n\t\tvar reduced = s[s.length-1];\n\t\toperands.add(reduced);\n\t}\n\tthis.opnds = operands.values();\n\treturn this;\n}\n\nOR.prototype = Object.create(SemanticContext.prototype);\nOR.prototype.constructor = OR;\n\nOR.prototype.constructor = function(other) {\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof OR)) {\n\t\treturn false;\n\t} else {\n\t\treturn this.opnds === other.opnds;\n\t}\n};\n\nOR.prototype.hashString = function() {\n\treturn \"\" + this.opnds + \"/OR\"; \n};\n\n// <p>\n// The evaluation of predicates by this context is short-circuiting, but\n// unordered.</p>\n//\nOR.prototype.evaluate = function(parser, outerContext) {\n\tfor (var i = 0; i < this.opnds.length; i++) {\n\t\tif (this.opnds[i].evaluate(parser, outerContext)) {\n\t\t\treturn true;\n\t\t}\n\t}\n\treturn false;\n};\n\nOR.prototype.evalPrecedence = function(parser, outerContext) {\n\tvar differs = false;\n\tvar operands = [];\n\tfor (var i = 0; i < this.opnds.length; i++) {\n\t\tvar context = this.opnds[i];\n\t\tvar evaluated = context.evalPrecedence(parser, outerContext);\n\t\tdiffers |= (evaluated !== context);\n\t\tif (evaluated === SemanticContext.NONE) {\n\t\t\t// The OR context is true if any element is true\n\t\t\treturn SemanticContext.NONE;\n\t\t} else if (evaluated !== null) {\n\t\t\t// Reduce the result by skipping false elements\n\t\t\toperands.push(evaluated);\n\t\t}\n\t}\n\tif (!differs) {\n\t\treturn this;\n\t}\n\tif (operands.length === 0) {\n\t\t// all elements were false, so the OR context is false\n\t\treturn null;\n\t}\n\tvar result = null;\n\toperands.map(function(o) {\n\t\treturn result === null ? o : SemanticContext.orContext(result, o);\n\t});\n\treturn result;\n};\n\nOR.prototype.toString = function() {\n\tvar s = \"\";\n\tthis.opnds.map(function(o) {\n\t\ts += \"|| \" + o.toString();\n\t});\n\treturn s.length > 3 ? s.slice(3) : s;\n};\n\nexports.SemanticContext = SemanticContext;\nexports.PrecedencePredicate = PrecedencePredicate;\nexports.Predicate = Predicate;\n\n},{\"./../Utils\":15}],30:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n//  An ATN transition between any two ATN states.  Subclasses define\n//  atom, set, epsilon, action, predicate, rule transitions.\n//\n//  <p>This is a one way link.  It emanates from a state (usually via a list of\n//  transitions) and has a target state.</p>\n//\n//  <p>Since we never have to change the ATN transitions once we construct it,\n//  we can fix these transitions as specific classes. The DFA transitions\n//  on the other hand need to update the labels as it adds transitions to\n//  the states. We'll use the term Edge for the DFA to distinguish them from\n//  ATN transitions.</p>\n\nvar Token = require('./../Token').Token;\nvar Interval = require('./../IntervalSet').Interval;\nvar IntervalSet = require('./../IntervalSet').IntervalSet;\nvar Predicate = require('./SemanticContext').Predicate;\nvar PrecedencePredicate = require('./SemanticContext').PrecedencePredicate;\n\nfunction Transition (target) {\n    // The target of this transition.\n    if (target===undefined || target===null) {\n        throw \"target cannot be null.\";\n    }\n    this.target = target;\n    // Are we epsilon, action, sempred?\n    this.isEpsilon = false;\n    this.label = null;\n    return this;\n}\n    // constants for serialization\nTransition.EPSILON = 1;\nTransition.RANGE = 2;\nTransition.RULE = 3;\nTransition.PREDICATE = 4; // e.g., {isType(input.LT(1))}?\nTransition.ATOM = 5;\nTransition.ACTION = 6;\nTransition.SET = 7; // ~(A|B) or ~atom, wildcard, which convert to next 2\nTransition.NOT_SET = 8;\nTransition.WILDCARD = 9;\nTransition.PRECEDENCE = 10;\n\nTransition.serializationNames = [\n            \"INVALID\",\n            \"EPSILON\",\n            \"RANGE\",\n            \"RULE\",\n            \"PREDICATE\",\n            \"ATOM\",\n            \"ACTION\",\n            \"SET\",\n            \"NOT_SET\",\n            \"WILDCARD\",\n            \"PRECEDENCE\"\n        ];\n\nTransition.serializationTypes = {\n        EpsilonTransition: Transition.EPSILON,\n        RangeTransition: Transition.RANGE,\n        RuleTransition: Transition.RULE,\n        PredicateTransition: Transition.PREDICATE,\n        AtomTransition: Transition.ATOM,\n        ActionTransition: Transition.ACTION,\n        SetTransition: Transition.SET,\n        NotSetTransition: Transition.NOT_SET,\n        WildcardTransition: Transition.WILDCARD,\n        PrecedencePredicateTransition: Transition.PRECEDENCE\n    };\n\n\n// TODO: make all transitions sets? no, should remove set edges\nfunction AtomTransition(target, label) {\n\tTransition.call(this, target);\n\tthis.label_ = label; // The token type or character value; or, signifies special label.\n    this.label = this.makeLabel();\n    this.serializationType = Transition.ATOM;\n    return this;\n}\n\nAtomTransition.prototype = Object.create(Transition.prototype);\nAtomTransition.prototype.constructor = AtomTransition;\n\nAtomTransition.prototype.makeLabel = function() {\n\tvar s = new IntervalSet();\n    s.addOne(this.label_);\n    return s;\n};\n\nAtomTransition.prototype.matches = function( symbol, minVocabSymbol,  maxVocabSymbol) {\n    return this.label_ === symbol;\n};\n\nAtomTransition.prototype.toString = function() {\n\treturn this.label_;\n};\n\nfunction RuleTransition(ruleStart, ruleIndex, precedence, followState) {\n\tTransition.call(this, ruleStart);\n    this.ruleIndex = ruleIndex; // ptr to the rule definition object for this rule ref\n    this.precedence = precedence;\n    this.followState = followState; // what node to begin computations following ref to rule\n    this.serializationType = Transition.RULE;\n    this.isEpsilon = true;\n    return this;\n}\n\nRuleTransition.prototype = Object.create(Transition.prototype);\nRuleTransition.prototype.constructor = RuleTransition;\n\nRuleTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn false;\n};\n\n\nfunction EpsilonTransition(target, outermostPrecedenceReturn) {\n\tTransition.call(this, target);\n    this.serializationType = Transition.EPSILON;\n    this.isEpsilon = true;\n    this.outermostPrecedenceReturn = outermostPrecedenceReturn;\n    return this;\n}\n\nEpsilonTransition.prototype = Object.create(Transition.prototype);\nEpsilonTransition.prototype.constructor = EpsilonTransition;\n\nEpsilonTransition.prototype.matches = function( symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn false;\n};\n\nEpsilonTransition.prototype.toString = function() {\n\treturn \"epsilon\";\n};\n\nfunction RangeTransition(target, start, stop) {\n\tTransition.call(this, target);\n\tthis.serializationType = Transition.RANGE;\n    this.start = start;\n    this.stop = stop;\n    this.label = this.makeLabel();\n    return this;\n}\n\nRangeTransition.prototype = Object.create(Transition.prototype);\nRangeTransition.prototype.constructor = RangeTransition;\n\nRangeTransition.prototype.makeLabel = function() {\n    var s = new IntervalSet();\n    s.addRange(this.start, this.stop);\n    return s;\n};\n\nRangeTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn symbol >= this.start && symbol <= this.stop;\n};\n\nRangeTransition.prototype.toString = function() {\n\treturn \"'\" + String.fromCharCode(this.start) + \"'..'\" + String.fromCharCode(this.stop) + \"'\";\n};\n\nfunction AbstractPredicateTransition(target) {\n\tTransition.call(this, target);\n\treturn this;\n}\n\nAbstractPredicateTransition.prototype = Object.create(Transition.prototype);\nAbstractPredicateTransition.prototype.constructor = AbstractPredicateTransition;\n\nfunction PredicateTransition(target, ruleIndex, predIndex, isCtxDependent) {\n\tAbstractPredicateTransition.call(this, target);\n    this.serializationType = Transition.PREDICATE;\n    this.ruleIndex = ruleIndex;\n    this.predIndex = predIndex;\n    this.isCtxDependent = isCtxDependent; // e.g., $i ref in pred\n    this.isEpsilon = true;\n    return this;\n}\n\nPredicateTransition.prototype = Object.create(AbstractPredicateTransition.prototype);\nPredicateTransition.prototype.constructor = PredicateTransition;\n\nPredicateTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn false;\n};\n\nPredicateTransition.prototype.getPredicate = function() {\n\treturn new Predicate(this.ruleIndex, this.predIndex, this.isCtxDependent);\n};\n\nPredicateTransition.prototype.toString = function() {\n\treturn \"pred_\" + this.ruleIndex + \":\" + this.predIndex;\n};\n\nfunction ActionTransition(target, ruleIndex, actionIndex, isCtxDependent) {\n\tTransition.call(this, target);\n    this.serializationType = Transition.ACTION;\n    this.ruleIndex = ruleIndex;\n    this.actionIndex = actionIndex===undefined ? -1 : actionIndex;\n    this.isCtxDependent = isCtxDependent===undefined ? false : isCtxDependent; // e.g., $i ref in pred\n    this.isEpsilon = true;\n    return this;\n}\n\nActionTransition.prototype = Object.create(Transition.prototype);\nActionTransition.prototype.constructor = ActionTransition;\n\n\nActionTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn false;\n};\n\nActionTransition.prototype.toString = function() {\n\treturn \"action_\" + this.ruleIndex + \":\" + this.actionIndex;\n};\n        \n\n// A transition containing a set of values.\nfunction SetTransition(target, set) {\n\tTransition.call(this, target);\n\tthis.serializationType = Transition.SET;\n    if (set !==undefined && set !==null) {\n        this.label = set;\n    } else {\n        this.label = new IntervalSet();\n        this.label.addOne(Token.INVALID_TYPE);\n    }\n    return this;\n}\n\nSetTransition.prototype = Object.create(Transition.prototype);\nSetTransition.prototype.constructor = SetTransition;\n\nSetTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn this.label.contains(symbol);\n};\n        \n\nSetTransition.prototype.toString = function() {\n\treturn this.label.toString();\n};\n\nfunction NotSetTransition(target, set) {\n\tSetTransition.call(this, target, set);\n\tthis.serializationType = Transition.NOT_SET;\n\treturn this;\n}\n\nNotSetTransition.prototype = Object.create(SetTransition.prototype);\nNotSetTransition.prototype.constructor = NotSetTransition;\n\nNotSetTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn symbol >= minVocabSymbol && symbol <= maxVocabSymbol &&\n\t\t\t!SetTransition.prototype.matches.call(this, symbol, minVocabSymbol, maxVocabSymbol);\n};\n\nNotSetTransition.prototype.toString = function() {\n\treturn '~' + SetTransition.prototype.toString.call(this);\n};\n\nfunction WildcardTransition(target) {\n\tTransition.call(this, target);\n\tthis.serializationType = Transition.WILDCARD;\n\treturn this;\n}\n\nWildcardTransition.prototype = Object.create(Transition.prototype);\nWildcardTransition.prototype.constructor = WildcardTransition;\n\n\nWildcardTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn symbol >= minVocabSymbol && symbol <= maxVocabSymbol;\n};\n\nWildcardTransition.prototype.toString = function() {\n\treturn \".\";\n};\n\nfunction PrecedencePredicateTransition(target, precedence) {\n\tAbstractPredicateTransition.call(this, target);\n    this.serializationType = Transition.PRECEDENCE;\n    this.precedence = precedence;\n    this.isEpsilon = true;\n    return this;\n}\n\nPrecedencePredicateTransition.prototype = Object.create(AbstractPredicateTransition.prototype);\nPrecedencePredicateTransition.prototype.constructor = PrecedencePredicateTransition;\n\nPrecedencePredicateTransition.prototype.matches = function(symbol, minVocabSymbol,  maxVocabSymbol) {\n\treturn false;\n};\n\nPrecedencePredicateTransition.prototype.getPredicate = function() {\n\treturn new PrecedencePredicate(this.precedence);\n};\n\nPrecedencePredicateTransition.prototype.toString = function() {\n\treturn this.precedence + \" >= _p\";\n};\n        \nexports.Transition = Transition;\nexports.AtomTransition = AtomTransition;\nexports.SetTransition = SetTransition;\nexports.NotSetTransition = NotSetTransition;\nexports.RuleTransition = RuleTransition;\nexports.ActionTransition = ActionTransition;\nexports.EpsilonTransition = EpsilonTransition;\nexports.RangeTransition = RangeTransition;\nexports.WildcardTransition = WildcardTransition;\nexports.PredicateTransition = PredicateTransition;\nexports.PrecedencePredicateTransition = PrecedencePredicateTransition;\nexports.AbstractPredicateTransition = AbstractPredicateTransition;\n},{\"./../IntervalSet\":6,\"./../Token\":14,\"./SemanticContext\":29}],31:[function(require,module,exports){\nexports.ATN = require('./ATN').ATN;\nexports.ATNDeserializer = require('./ATNDeserializer').ATNDeserializer;\nexports.LexerATNSimulator = require('./LexerATNSimulator').LexerATNSimulator;\nexports.ParserATNSimulator = require('./ParserATNSimulator').ParserATNSimulator;\nexports.PredictionMode = require('./PredictionMode').PredictionMode;\n},{\"./ATN\":16,\"./ATNDeserializer\":20,\"./LexerATNSimulator\":24,\"./ParserATNSimulator\":27,\"./PredictionMode\":28}],32:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nvar DFAState = require('./DFAState').DFAState;\nvar ATNConfigSet = require('./../atn/ATNConfigSet').ATNConfigSet;\nvar DFASerializer = require('./DFASerializer').DFASerializer;\nvar LexerDFASerializer = require('./DFASerializer').LexerDFASerializer;\n\nfunction DFAStatesSet() {\n\treturn this;\n}\n\nObject.defineProperty(DFAStatesSet.prototype, \"length\", {\n\tget : function() {\n\t\treturn Object.keys(this).length;\n\t}\n});\n\nfunction DFA(atnStartState, decision) {\n\tif (decision === undefined) {\n\t\tdecision = 0;\n\t}\n\t// From which ATN state did we create this DFA?\n\tthis.atnStartState = atnStartState;\n\tthis.decision = decision;\n\t// A set of all DFA states. Use {@link Map} so we can get old state back\n\t// ({@link Set} only allows you to see if it's there).\n\tthis._states = new DFAStatesSet();\n\tthis.s0 = null;\n\t// {@code true} if this DFA is for a precedence decision; otherwise,\n\t// {@code false}. This is the backing field for {@link //isPrecedenceDfa},\n\t// {@link //setPrecedenceDfa}.\n\tthis.precedenceDfa = false;\n\treturn this;\n}\n\n// Get the start state for a specific precedence value.\n//\n// @param precedence The current precedence.\n// @return The start state corresponding to the specified precedence, or\n// {@code null} if no start state exists for the specified precedence.\n//\n// @throws IllegalStateException if this is not a precedence DFA.\n// @see //isPrecedenceDfa()\n\nDFA.prototype.getPrecedenceStartState = function(precedence) {\n\tif (!(this.precedenceDfa)) {\n\t\tthrow (\"Only precedence DFAs may contain a precedence start state.\");\n\t}\n\t// s0.edges is never null for a precedence DFA\n\tif (precedence < 0 || precedence >= this.s0.edges.length) {\n\t\treturn null;\n\t}\n\treturn this.s0.edges[precedence] || null;\n};\n\n// Set the start state for a specific precedence value.\n//\n// @param precedence The current precedence.\n// @param startState The start state corresponding to the specified\n// precedence.\n//\n// @throws IllegalStateException if this is not a precedence DFA.\n// @see //isPrecedenceDfa()\n//\nDFA.prototype.setPrecedenceStartState = function(precedence, startState) {\n\tif (!(this.precedenceDfa)) {\n\t\tthrow (\"Only precedence DFAs may contain a precedence start state.\");\n\t}\n\tif (precedence < 0) {\n\t\treturn;\n\t}\n\n\t// synchronization on s0 here is ok. when the DFA is turned into a\n\t// precedence DFA, s0 will be initialized once and not updated again\n\t// s0.edges is never null for a precedence DFA\n\tthis.s0.edges[precedence] = startState;\n};\n\n//\n// Sets whether this is a precedence DFA. If the specified value differs\n// from the current DFA configuration, the following actions are taken;\n// otherwise no changes are made to the current DFA.\n//\n// <ul>\n// <li>The {@link //states} map is cleared</li>\n// <li>If {@code precedenceDfa} is {@code false}, the initial state\n// {@link //s0} is set to {@code null}; otherwise, it is initialized to a new\n// {@link DFAState} with an empty outgoing {@link DFAState//edges} array to\n// store the start states for individual precedence values.</li>\n// <li>The {@link //precedenceDfa} field is updated</li>\n// </ul>\n//\n// @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,\n// {@code false}\n\nDFA.prototype.setPrecedenceDfa = function(precedenceDfa) {\n\tif (this.precedenceDfa!==precedenceDfa) {\n\t\tthis._states = new DFAStatesSet();\n\t\tif (precedenceDfa) {\n\t\t\tvar precedenceState = new DFAState(new ATNConfigSet());\n\t\t\tprecedenceState.edges = [];\n\t\t\tprecedenceState.isAcceptState = false;\n\t\t\tprecedenceState.requiresFullContext = false;\n\t\t\tthis.s0 = precedenceState;\n\t\t} else {\n\t\t\tthis.s0 = null;\n\t\t}\n\t\tthis.precedenceDfa = precedenceDfa;\n\t}\n};\n\nObject.defineProperty(DFA.prototype, \"states\", {\n\tget : function() {\n\t\treturn this._states;\n\t}\n});\n\n// Return a list of all states in this DFA, ordered by state number.\nDFA.prototype.sortedStates = function() {\n\t// states_ is a map of state/state, where key=value\n\tvar keys = Object.keys(this._states);\n\tvar list = [];\n\tfor(var i=0;i<keys.length;i++) {\n\t\tlist.push(this._states[keys[i]]);\n\t}\n\treturn list.sort(function(a, b) {\n\t\treturn a.stateNumber - b.stateNumber;\n\t});\n};\n\nDFA.prototype.toString = function(literalNames, symbolicNames) {\n\tliteralNames = literalNames || null;\n\tsymbolicNames = symbolicNames || null;\n\tif (this.s0 === null) {\n\t\treturn \"\";\n\t}\n\tvar serializer = new DFASerializer(this, literalNames, symbolicNames);\n\treturn serializer.toString();\n};\n\nDFA.prototype.toLexerString = function() {\n\tif (this.s0 === null) {\n\t\treturn \"\";\n\t}\n\tvar serializer = new LexerDFASerializer(this);\n\treturn serializer.toString();\n};\n\nexports.DFA = DFA;\n\n},{\"./../atn/ATNConfigSet\":18,\"./DFASerializer\":33,\"./DFAState\":34}],33:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n// A DFA walker that knows how to dump them to serialized strings.#/\n\n\nfunction DFASerializer(dfa, literalNames, symbolicNames) {\n\tthis.dfa = dfa;\n\tthis.literalNames = literalNames || [];\n\tthis.symbolicNames = symbolicNames || [];\n\treturn this;\n}\n\nDFASerializer.prototype.toString = function() {\n   if(this.dfa.s0 === null) {\n       return null;\n   }\n   var buf = \"\";\n   var states = this.dfa.sortedStates();\n   for(var i=0;i<states.length;i++) {\n       var s = states[i];\n       if(s.edges!==null) {\n            var n = s.edges.length;\n            for(var j=0;j<n;j++) {\n                var t = s.edges[j] || null;\n                if(t!==null && t.stateNumber !== 0x7FFFFFFF) {\n                    buf = buf.concat(this.getStateString(s));\n                    buf = buf.concat(\"-\");\n                    buf = buf.concat(this.getEdgeLabel(j));\n                    buf = buf.concat(\"->\");\n                    buf = buf.concat(this.getStateString(t));\n                    buf = buf.concat('\\n');\n                }\n            }\n       }\n   }\n   return buf.length===0 ? null : buf;\n};\n\nDFASerializer.prototype.getEdgeLabel = function(i) {\n    if (i===0) {\n        return \"EOF\";\n    } else if(this.literalNames !==null || this.symbolicNames!==null) {\n        return this.literalNames[i-1] || this.symbolicNames[i-1];\n    } else {\n        return String.fromCharCode(i-1);\n    }\n};\n\nDFASerializer.prototype.getStateString = function(s) {\n    var baseStateStr = ( s.isAcceptState ? \":\" : \"\") + \"s\" + s.stateNumber + ( s.requiresFullContext ? \"^\" : \"\");\n    if(s.isAcceptState) {\n        if (s.predicates !== null) {\n            return baseStateStr + \"=>\" + s.predicates.toString();\n        } else {\n            return baseStateStr + \"=>\" + s.prediction.toString();\n        }\n    } else {\n        return baseStateStr;\n    }\n};\n\nfunction LexerDFASerializer(dfa) {\n\tDFASerializer.call(this, dfa, null);\n\treturn this;\n}\n\nLexerDFASerializer.prototype = Object.create(DFASerializer.prototype);\nLexerDFASerializer.prototype.constructor = LexerDFASerializer;\n\nLexerDFASerializer.prototype.getEdgeLabel = function(i) {\n\treturn \"'\" + String.fromCharCode(i) + \"'\";\n};\n\nexports.DFASerializer = DFASerializer;\nexports.LexerDFASerializer = LexerDFASerializer;\n\n\n},{}],34:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\nvar ATNConfigSet = require('./../atn/ATNConfigSet').ATNConfigSet;\nvar Utils = require('./../Utils');\nvar Set = Utils.Set;\n\n// Map a predicate to a predicted alternative.///\n\nfunction PredPrediction(pred, alt) {\n\tthis.alt = alt;\n\tthis.pred = pred;\n\treturn this;\n}\n\nPredPrediction.prototype.toString = function() {\n\treturn \"(\" + this.pred + \", \" + this.alt + \")\";\n};\n\n// A DFA state represents a set of possible ATN configurations.\n// As Aho, Sethi, Ullman p. 117 says \"The DFA uses its state\n// to keep track of all possible states the ATN can be in after\n// reading each input symbol. That is to say, after reading\n// input a1a2..an, the DFA is in a state that represents the\n// subset T of the states of the ATN that are reachable from the\n// ATN's start state along some path labeled a1a2..an.\"\n// In conventional NFA&rarr;DFA conversion, therefore, the subset T\n// would be a bitset representing the set of states the\n// ATN could be in. We need to track the alt predicted by each\n// state as well, however. More importantly, we need to maintain\n// a stack of states, tracking the closure operations as they\n// jump from rule to rule, emulating rule invocations (method calls).\n// I have to add a stack to simulate the proper lookahead sequences for\n// the underlying LL grammar from which the ATN was derived.\n//\n// <p>I use a set of ATNConfig objects not simple states. An ATNConfig\n// is both a state (ala normal conversion) and a RuleContext describing\n// the chain of rules (if any) followed to arrive at that state.</p>\n//\n// <p>A DFA state may have multiple references to a particular state,\n// but with different ATN contexts (with same or different alts)\n// meaning that state was reached via a different set of rule invocations.</p>\n// /\n\nfunction DFAState(stateNumber, configs) {\n\tif (stateNumber === null) {\n\t\tstateNumber = -1;\n\t}\n\tif (configs === null) {\n\t\tconfigs = new ATNConfigSet();\n\t}\n\tthis.stateNumber = stateNumber;\n\tthis.configs = configs;\n\t// {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)\n\t// {@link Token//EOF} maps to {@code edges[0]}.\n\tthis.edges = null;\n\tthis.isAcceptState = false;\n\t// if accept state, what ttype do we match or alt do we predict?\n\t// This is set to {@link ATN//INVALID_ALT_NUMBER} when {@link\n\t// //predicates}{@code !=null} or\n\t// {@link //requiresFullContext}.\n\tthis.prediction = 0;\n\tthis.lexerActionExecutor = null;\n\t// Indicates that this state was created during SLL prediction that\n\t// discovered a conflict between the configurations in the state. Future\n\t// {@link ParserATNSimulator//execATN} invocations immediately jumped doing\n\t// full context prediction if this field is true.\n\tthis.requiresFullContext = false;\n\t// During SLL parsing, this is a list of predicates associated with the\n\t// ATN configurations of the DFA state. When we have predicates,\n\t// {@link //requiresFullContext} is {@code false} since full context\n\t// prediction evaluates predicates\n\t// on-the-fly. If this is not null, then {@link //prediction} is\n\t// {@link ATN//INVALID_ALT_NUMBER}.\n\t//\n\t// <p>We only use these for non-{@link //requiresFullContext} but\n\t// conflicting states. That\n\t// means we know from the context (it's $ or we don't dip into outer\n\t// context) that it's an ambiguity not a conflict.</p>\n\t//\n\t// <p>This list is computed by {@link\n\t// ParserATNSimulator//predicateDFAState}.</p>\n\tthis.predicates = null;\n\treturn this;\n}\n\n// Get the set of all alts mentioned by all ATN configurations in this\n// DFA state.\nDFAState.prototype.getAltSet = function() {\n\tvar alts = new Set();\n\tif (this.configs !== null) {\n\t\tfor (var i = 0; i < this.configs.length; i++) {\n\t\t\tvar c = this.configs[i];\n\t\t\talts.add(c.alt);\n\t\t}\n\t}\n\tif (alts.length === 0) {\n\t\treturn null;\n\t} else {\n\t\treturn alts;\n\t}\n};\n\n// Two {@link DFAState} instances are equal if their ATN configuration sets\n// are the same. This method is used to see if a state already exists.\n//\n// <p>Because the number of alternatives and number of ATN configurations are\n// finite, there is a finite number of DFA states that can be processed.\n// This is necessary to show that the algorithm terminates.</p>\n//\n// <p>Cannot test the DFA state numbers here because in\n// {@link ParserATNSimulator//addDFAState} we need to know if any other state\n// exists that has this exact set of ATN configurations. The\n// {@link //stateNumber} is irrelevant.</p>\nDFAState.prototype.equals = function(other) {\n\t// compare set of ATN configurations in this set with other\n\tif (this === other) {\n\t\treturn true;\n\t} else if (!(other instanceof DFAState)) {\n\t\treturn false;\n\t} else {\n\t\treturn this.configs.equals(other.configs);\n\t}\n};\n\nDFAState.prototype.toString = function() {\n\treturn \"\" + this.stateNumber + \":\" + this.hashString();\n};\n\nDFAState.prototype.hashString = function() {\n\treturn \"\" +  this.configs +\n\t\t\t(this.isAcceptState ?\n\t\t\t\t\t\"=>\" + (this.predicates !== null ?\n\t\t\t\t\t\t\t\tthis.predicates :\n\t\t\t\t\t\t\t\tthis.prediction) :\n\t\t\t\t\t\"\");\n};\n\nexports.DFAState = DFAState;\nexports.PredPrediction = PredPrediction;\n\n},{\"./../Utils\":15,\"./../atn/ATNConfigSet\":18}],35:[function(require,module,exports){\nexports.DFA = require('./DFA').DFA;\nexports.DFASerializer = require('./DFASerializer').DFASerializer;\nexports.LexerDFASerializer = require('./DFASerializer').LexerDFASerializer;\nexports.PredPrediction = require('./DFAState').PredPrediction;\n\n},{\"./DFA\":32,\"./DFASerializer\":33,\"./DFAState\":34}],36:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\n//\n// This implementation of {@link ANTLRErrorListener} can be used to identify\n// certain potential correctness and performance problems in grammars. \"Reports\"\n// are made by calling {@link Parser//notifyErrorListeners} with the appropriate\n// message.\n//\n// <ul>\n// <li><b>Ambiguities</b>: These are cases where more than one path through the\n// grammar can match the input.</li>\n// <li><b>Weak context sensitivity</b>: These are cases where full-context\n// prediction resolved an SLL conflict to a unique alternative which equaled the\n// minimum alternative of the SLL conflict.</li>\n// <li><b>Strong (forced) context sensitivity</b>: These are cases where the\n// full-context prediction resolved an SLL conflict to a unique alternative,\n// <em>and</em> the minimum alternative of the SLL conflict was found to not be\n// a truly viable alternative. Two-stage parsing cannot be used for inputs where\n// this situation occurs.</li>\n// </ul>\n\nvar BitSet = require('./../Utils').BitSet;\nvar ErrorListener = require('./ErrorListener').ErrorListener;\nvar Interval = require('./../IntervalSet').Interval;\n\nfunction DiagnosticErrorListener(exactOnly) {\n\tErrorListener.call(this);\n\texactOnly = exactOnly || true;\n\t// whether all ambiguities or only exact ambiguities are reported.\n\tthis.exactOnly = exactOnly;\n\treturn this;\n}\n\nDiagnosticErrorListener.prototype = Object.create(ErrorListener.prototype);\nDiagnosticErrorListener.prototype.constructor = DiagnosticErrorListener;\n\nDiagnosticErrorListener.prototype.reportAmbiguity = function(recognizer, dfa,\n\t\tstartIndex, stopIndex, exact, ambigAlts, configs) {\n\tif (this.exactOnly && !exact) {\n\t\treturn;\n\t}\n\tvar msg = \"reportAmbiguity d=\" +\n\t\t\tthis.getDecisionDescription(recognizer, dfa) +\n\t\t\t\": ambigAlts=\" +\n\t\t\tthis.getConflictingAlts(ambigAlts, configs) +\n\t\t\t\", input='\" +\n\t\t\trecognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + \"'\";\n\trecognizer.notifyErrorListeners(msg);\n};\n\nDiagnosticErrorListener.prototype.reportAttemptingFullContext = function(\n\t\trecognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {\n\tvar msg = \"reportAttemptingFullContext d=\" +\n\t\t\tthis.getDecisionDescription(recognizer, dfa) +\n\t\t\t\", input='\" +\n\t\t\trecognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + \"'\";\n\trecognizer.notifyErrorListeners(msg);\n};\n\nDiagnosticErrorListener.prototype.reportContextSensitivity = function(\n\t\trecognizer, dfa, startIndex, stopIndex, prediction, configs) {\n\tvar msg = \"reportContextSensitivity d=\" +\n\t\t\tthis.getDecisionDescription(recognizer, dfa) +\n\t\t\t\", input='\" +\n\t\t\trecognizer.getTokenStream().getText(new Interval(startIndex, stopIndex)) + \"'\";\n\trecognizer.notifyErrorListeners(msg);\n};\n\nDiagnosticErrorListener.prototype.getDecisionDescription = function(recognizer, dfa) {\n\tvar decision = dfa.decision;\n\tvar ruleIndex = dfa.atnStartState.ruleIndex;\n\n\tvar ruleNames = recognizer.ruleNames;\n\tif (ruleIndex < 0 || ruleIndex >= ruleNames.length) {\n\t\treturn \"\" + decision;\n\t}\n\tvar ruleName = ruleNames[ruleIndex] || null;\n\tif (ruleName === null || ruleName.length === 0) {\n\t\treturn \"\" + decision;\n\t}\n\treturn \"\" + decision + \" (\" + ruleName + \")\";\n};\n\n//\n// Computes the set of conflicting or ambiguous alternatives from a\n// configuration set, if that information was not already provided by the\n// parser.\n//\n// @param reportedAlts The set of conflicting or ambiguous alternatives, as\n// reported by the parser.\n// @param configs The conflicting or ambiguous configuration set.\n// @return Returns {@code reportedAlts} if it is not {@code null}, otherwise\n// returns the set of alternatives represented in {@code configs}.\n//\nDiagnosticErrorListener.prototype.getConflictingAlts = function(reportedAlts, configs) {\n\tif (reportedAlts !== null) {\n\t\treturn reportedAlts;\n\t}\n\tvar result = new BitSet();\n\tfor (var i = 0; i < configs.items.length; i++) {\n\t\tresult.add(configs.items[i].alt);\n\t}\n\treturn \"{\" + result.values().join(\", \") + \"}\";\n};\n\nexports.DiagnosticErrorListener = DiagnosticErrorListener;\n},{\"./../IntervalSet\":6,\"./../Utils\":15,\"./ErrorListener\":37}],37:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n// Provides an empty default implementation of {@link ANTLRErrorListener}. The\n// default implementation of each method does nothing, but can be overridden as\n// necessary.\n\nfunction ErrorListener() {\n\treturn this;\n}\n\nErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {\n};\n\nErrorListener.prototype.reportAmbiguity = function(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {\n};\n\nErrorListener.prototype.reportAttemptingFullContext = function(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {\n};\n\nErrorListener.prototype.reportContextSensitivity = function(recognizer, dfa, startIndex, stopIndex, prediction, configs) {\n};\n\nfunction ConsoleErrorListener() {\n\tErrorListener.call(this);\n\treturn this;\n}\n\nConsoleErrorListener.prototype = Object.create(ErrorListener.prototype);\nConsoleErrorListener.prototype.constructor = ConsoleErrorListener;\n\n//\n// Provides a default instance of {@link ConsoleErrorListener}.\n//\nConsoleErrorListener.INSTANCE = new ConsoleErrorListener();\n\n//\n// {@inheritDoc}\n//\n// <p>\n// This implementation prints messages to {@link System//err} containing the\n// values of {@code line}, {@code charPositionInLine}, and {@code msg} using\n// the following format.</p>\n//\n// <pre>\n// line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>\n// </pre>\n//\nConsoleErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {\n    console.error(\"line \" + line + \":\" + column + \" \" + msg);\n};\n\nfunction ProxyErrorListener(delegates) {\n\tErrorListener.call(this);\n    if (delegates===null) {\n        throw \"delegates\";\n    }\n    this.delegates = delegates;\n\treturn this;\n}\n\nProxyErrorListener.prototype = Object.create(ErrorListener.prototype);\nProxyErrorListener.prototype.constructor = ProxyErrorListener;\n\nProxyErrorListener.prototype.syntaxError = function(recognizer, offendingSymbol, line, column, msg, e) {\n    this.delegates.map(function(d) { d.syntaxError(recognizer, offendingSymbol, line, column, msg, e); });\n};\n\nProxyErrorListener.prototype.reportAmbiguity = function(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {\n    this.delegates.map(function(d) { d.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs); });\n};\n\nProxyErrorListener.prototype.reportAttemptingFullContext = function(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {\n\tthis.delegates.map(function(d) { d.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs); });\n};\n\nProxyErrorListener.prototype.reportContextSensitivity = function(recognizer, dfa, startIndex, stopIndex, prediction, configs) {\n\tthis.delegates.map(function(d) { d.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs); });\n};\n\nexports.ErrorListener = ErrorListener;\nexports.ConsoleErrorListener = ConsoleErrorListener;\nexports.ProxyErrorListener = ProxyErrorListener;\n\n\n},{}],38:[function(require,module,exports){\n//\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n//\n\nvar Token = require('./../Token').Token;\nvar Errors = require('./Errors');\nvar NoViableAltException = Errors.NoViableAltException;\nvar InputMismatchException = Errors.InputMismatchException;\nvar FailedPredicateException = Errors.FailedPredicateException;\nvar ParseCancellationException = Errors.ParseCancellationException;\nvar ATNState = require('./../atn/ATNState').ATNState;\nvar Interval = require('./../IntervalSet').Interval;\nvar IntervalSet = require('./../IntervalSet').IntervalSet;\n\nfunction ErrorStrategy() {\n\t\n}\n\nErrorStrategy.prototype.reset = function(recognizer){\n};\n\nErrorStrategy.prototype.recoverInline = function(recognizer){\n};\n\nErrorStrategy.prototype.recover = function(recognizer, e){\n};\n\nErrorStrategy.prototype.sync = function(recognizer){\n};\n\nErrorStrategy.prototype.inErrorRecoveryMode = function(recognizer){\n};\n\nErrorStrategy.prototype.reportError = function(recognizer){\n};\n\n\n\n// This is the default implementation of {@link ANTLRErrorStrategy} used for\n// error reporting and recovery in ANTLR parsers.\n//\nfunction DefaultErrorStrategy() {\n\tErrorStrategy.call(this);\n    // Indicates whether the error strategy is currently \"recovering from an\n    // error\". This is used to suppress reporting multiple error messages while\n    // attempting to recover from a detected syntax error.\n    //\n    // @see //inErrorRecoveryMode\n    //\n    this.errorRecoveryMode = false;\n\n    // The index into the input stream where the last error occurred.\n    // This is used to prevent infinite loops where an error is found\n    // but no token is consumed during recovery...another error is found,\n    // ad nauseum. This is a failsafe mechanism to guarantee that at least\n    // one token/tree node is consumed for two errors.\n    //\n    this.lastErrorIndex = -1;\n    this.lastErrorStates = null;\n    return this;\n}\n\nDefaultErrorStrategy.prototype = Object.create(ErrorStrategy.prototype);\nDefaultErrorStrategy.prototype.constructor = DefaultErrorStrategy;\n\n// <p>The default implementation simply calls {@link //endErrorCondition} to\n// ensure that the handler is not in error recovery mode.</p>\nDefaultErrorStrategy.prototype.reset = function(recognizer) {\n    this.endErrorCondition(recognizer);\n};\n\n//\n// This method is called to enter error recovery mode when a recognition\n// exception is reported.\n//\n// @param recognizer the parser instance\n//\nDefaultErrorStrategy.prototype.beginErrorCondition = function(recognizer) {\n    this.errorRecoveryMode = true;\n};\n\nDefaultErrorStrategy.prototype.inErrorRecoveryMode = function(recognizer) {\n    return this.errorRecoveryMode;\n};\n\n//\n// This method is called to leave error recovery mode after recovering from\n// a recognition exception.\n//\n// @param recognizer\n//\nDefaultErrorStrategy.prototype.endErrorCondition = function(recognizer) {\n    this.errorRecoveryMode = false;\n    this.lastErrorStates = null;\n    this.lastErrorIndex = -1;\n};\n\n//\n// {@inheritDoc}\n//\n// <p>The default implementation simply calls {@link //endErrorCondition}.</p>\n//\nDefaultErrorStrategy.prototype.reportMatch = function(recognizer) {\n    this.endErrorCondition(recognizer);\n};\n\n//\n// {@inheritDoc}\n//\n// <p>The default implementation returns immediately if the handler is already\n// in error recovery mode. Otherwise, it calls {@link //beginErrorCondition}\n// and dispatches the reporting task based on the runtime type of {@code e}\n// according to the following table.</p>\n//\n// <ul>\n// <li>{@link NoViableAltException}: Dispatches the call to\n// {@link //reportNoViableAlternative}</li>\n// <li>{@link InputMismatchException}: Dispatches the call to\n// {@link //reportInputMismatch}</li>\n// <li>{@link FailedPredicateException}: Dispatches the call to\n// {@link //reportFailedPredicate}</li>\n// <li>All other types: calls {@link Parser//notifyErrorListeners} to report\n// the exception</li>\n// </ul>\n//\nDefaultErrorStrategy.prototype.reportError = function(recognizer, e) {\n   // if we've already reported an error and have not matched a token\n   // yet successfully, don't report any errors.\n    if(this.inErrorRecoveryMode(recognizer)) {\n        return; // don't report spurious errors\n    }\n    this.beginErrorCondition(recognizer);\n    if ( e instanceof NoViableAltException ) {\n        this.reportNoViableAlternative(recognizer, e);\n    } else if ( e instanceof InputMismatchException ) {\n        this.reportInputMismatch(recognizer, e);\n    } else if ( e instanceof FailedPredicateException ) {\n        this.reportFailedPredicate(recognizer, e);\n    } else {\n        console.log(\"unknown recognition error type: \" + e.constructor.name);\n        console.log(e.stack);\n        recognizer.notifyErrorListeners(e.getOffendingToken(), e.getMessage(), e);\n    }\n};\n//\n// {@inheritDoc}\n//\n// <p>The default implementation resynchronizes the parser by consuming tokens\n// until we find one in the resynchronization set--loosely the set of tokens\n// that can follow the current rule.</p>\n//\nDefaultErrorStrategy.prototype.recover = function(recognizer, e) {\n    if (this.lastErrorIndex===recognizer.getInputStream().index &&\n        this.lastErrorStates !== null && this.lastErrorStates.indexOf(recognizer.state)>=0) {\n\t\t// uh oh, another error at same token index and previously-visited\n\t\t// state in ATN; must be a case where LT(1) is in the recovery\n\t\t// token set so nothing got consumed. Consume a single token\n\t\t// at least to prevent an infinite loop; this is a failsafe.\n\t\trecognizer.consume();\n    }\n    this.lastErrorIndex = recognizer._input.index;\n    if (this.lastErrorStates === null) {\n        this.lastErrorStates = [];\n    }\n    this.lastErrorStates.push(recognizer.state);\n    var followSet = this.getErrorRecoverySet(recognizer);\n    this.consumeUntil(recognizer, followSet);\n};\n\n// The default implementation of {@link ANTLRErrorStrategy//sync} makes sure\n// that the current lookahead symbol is consistent with what were expecting\n// at this point in the ATN. You can call this anytime but ANTLR only\n// generates code to check before subrules/loops and each iteration.\n//\n// <p>Implements Jim Idle's magic sync mechanism in closures and optional\n// subrules. E.g.,</p>\n//\n// <pre>\n// a : sync ( stuff sync )* ;\n// sync : {consume to what can follow sync} ;\n// </pre>\n//\n// At the start of a sub rule upon error, {@link //sync} performs single\n// token deletion, if possible. If it can't do that, it bails on the current\n// rule and uses the default error recovery, which consumes until the\n// resynchronization set of the current rule.\n//\n// <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block\n// with an empty alternative), then the expected set includes what follows\n// the subrule.</p>\n//\n// <p>During loop iteration, it consumes until it sees a token that can start a\n// sub rule or what follows loop. Yes, that is pretty aggressive. We opt to\n// stay in the loop as long as possible.</p>\n//\n// <p><strong>ORIGINS</strong></p>\n//\n// <p>Previous versions of ANTLR did a poor job of their recovery within loops.\n// A single mismatch token or missing token would force the parser to bail\n// out of the entire rules surrounding the loop. So, for rule</p>\n//\n// <pre>\n// classDef : 'class' ID '{' member* '}'\n// </pre>\n//\n// input with an extra token between members would force the parser to\n// consume until it found the next class definition rather than the next\n// member definition of the current class.\n//\n// <p>This functionality cost a little bit of effort because the parser has to\n// compare token set at the start of the loop and at each iteration. If for\n// some reason speed is suffering for you, you can turn off this\n// functionality by simply overriding this method as a blank { }.</p>\n//\nDefaultErrorStrategy.prototype.sync = function(recognizer) {\n    // If already recovering, don't try to sync\n    if (this.inErrorRecoveryMode(recognizer)) {\n        return;\n    }\n    var s = recognizer._interp.atn.states[recognizer.state];\n    var la = recognizer.getTokenStream().LA(1);\n    // try cheaper subset first; might get lucky. seems to shave a wee bit off\n    if (la===Token.EOF || recognizer.atn.nextTokens(s).contains(la)) {\n        return;\n    }\n    // Return but don't end recovery. only do that upon valid token match\n    if(recognizer.isExpectedToken(la)) {\n        return;\n    }\n    switch (s.stateType) {\n    case ATNState.BLOCK_START:\n    case ATNState.STAR_BLOCK_START:\n    case ATNState.PLUS_BLOCK_START:\n    case ATNState.STAR_LOOP_ENTRY:\n       // report error and recover if possible\n        if( this.singleTokenDeletion(recognizer) !== null) {\n            return;\n        } else {\n            throw new InputMismatchException(recognizer);\n        }\n        break;\n    case ATNState.PLUS_LOOP_BACK:\n    case ATNState.STAR_LOOP_BACK:\n        this.reportUnwantedToken(recognizer);\n        var expecting = new IntervalSet();\n        expecting.addSet(recognizer.getExpectedTokens());\n        var whatFollowsLoopIterationOrRule = expecting.addSet(this.getErrorRecoverySet(recognizer));\n        this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);\n        break;\n    default:\n        // do nothing if we can't identify the exact kind of ATN state\n    }\n};\n\n// This is called by {@link //reportError} when the exception is a\n// {@link NoViableAltException}.\n//\n// @see //reportError\n//\n// @param recognizer the parser instance\n// @param e the recognition exception\n//\nDefaultErrorStrategy.prototype.reportNoViableAlternative = function(recognizer, e) {\n    var tokens = recognizer.getTokenStream();\n    var input;\n    if(tokens !== null) {\n        if (e.startToken.type===Token.EOF) {\n            input = \"<EOF>\";\n        } else {\n            input = tokens.getText(new Interval(e.startToken, e.offendingToken));\n        }\n    } else {\n        input = \"<unknown input>\";\n    }\n    var msg = \"no viable alternative at input \" + this.escapeWSAndQuote(input);\n    recognizer.notifyErrorListeners(msg, e.offendingToken, e);\n};\n\n//\n// This is called by {@link //reportError} when the exception is an\n// {@link InputMismatchException}.\n//\n// @see //reportError\n//\n// @param recognizer the parser instance\n// @param e the recognition exception\n//\nDefaultErrorStrategy.prototype.reportInputMismatch = function(recognizer, e) {\n    var msg = \"mismatched input \" + this.getTokenErrorDisplay(e.offendingToken) +\n          \" expecting \" + e.getExpectedTokens().toString(recognizer.literalNames, recognizer.symbolicNames);\n    recognizer.notifyErrorListeners(msg, e.offendingToken, e);\n};\n\n//\n// This is called by {@link //reportError} when the exception is a\n// {@link FailedPredicateException}.\n//\n// @see //reportError\n//\n// @param recognizer the parser instance\n// @param e the recognition exception\n//\nDefaultErrorStrategy.prototype.reportFailedPredicate = function(recognizer, e) {\n    var ruleName = recognizer.ruleNames[recognizer._ctx.ruleIndex];\n    var msg = \"rule \" + ruleName + \" \" + e.message;\n    recognizer.notifyErrorListeners(msg, e.offendingToken, e);\n};\n\n// This method is called to report a syntax error which requires the removal\n// of a token from the input stream. At the time this method is called, the\n// erroneous symbol is current {@code LT(1)} symbol and has not yet been\n// removed from the input stream. When this method returns,\n// {@code recognizer} is in error recovery mode.\n//\n// <p>This method is called when {@link //singleTokenDeletion} identifies\n// single-token deletion as a viable recovery strategy for a mismatched\n// input error.</p>\n//\n// <p>The default implementation simply returns if the handler is already in\n// error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to\n// enter error recovery mode, followed by calling\n// {@link Parser//notifyErrorListeners}.</p>\n//\n// @param recognizer the parser instance\n//\nDefaultErrorStrategy.prototype.reportUnwantedToken = function(recognizer) {\n    if (this.inErrorRecoveryMode(recognizer)) {\n        return;\n    }\n    this.beginErrorCondition(recognizer);\n    var t = recognizer.getCurrentToken();\n    var tokenName = this.getTokenErrorDisplay(t);\n    var expecting = this.getExpectedTokens(recognizer);\n    var msg = \"extraneous input \" + tokenName + \" expecting \" +\n        expecting.toString(recognizer.literalNames, recognizer.symbolicNames);\n    recognizer.notifyErrorListeners(msg, t, null);\n};\n// This method is called to report a syntax error which requires the\n// insertion of a missing token into the input stream. At the time this\n// method is called, the missing token has not yet been inserted. When this\n// method returns, {@code recognizer} is in error recovery mode.\n//\n// <p>This method is called when {@link //singleTokenInsertion} identifies\n// single-token insertion as a viable recovery strategy for a mismatched\n// input error.</p>\n//\n// <p>The default implementation simply returns if the handler is already in\n// error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to\n// enter error recovery mode, followed by calling\n// {@link Parser//notifyErrorListeners}.</p>\n//\n// @param recognizer the parser instance\n//\nDefaultErrorStrategy.prototype.reportMissingToken = function(recognizer) {\n    if ( this.inErrorRecoveryMode(recognizer)) {\n        return;\n    }\n    this.beginErrorCondition(recognizer);\n    var t = recognizer.getCurrentToken();\n    var expecting = this.getExpectedTokens(recognizer);\n    var msg = \"missing \" + expecting.toString(recognizer.literalNames, recognizer.symbolicNames) +\n          \" at \" + this.getTokenErrorDisplay(t);\n    recognizer.notifyErrorListeners(msg, t, null);\n};\n\n// <p>The default implementation attempts to recover from the mismatched input\n// by using single token insertion and deletion as described below. If the\n// recovery attempt fails, this method throws an\n// {@link InputMismatchException}.</p>\n//\n// <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>\n//\n// <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the\n// right token, however, then assume {@code LA(1)} is some extra spurious\n// token and delete it. Then consume and return the next token (which was\n// the {@code LA(2)} token) as the successful result of the match operation.</p>\n//\n// <p>This recovery strategy is implemented by {@link\n// //singleTokenDeletion}.</p>\n//\n// <p><strong>MISSING TOKEN</strong> (single token insertion)</p>\n//\n// <p>If current token (at {@code LA(1)}) is consistent with what could come\n// after the expected {@code LA(1)} token, then assume the token is missing\n// and use the parser's {@link TokenFactory} to create it on the fly. The\n// \"insertion\" is performed by returning the created token as the successful\n// result of the match operation.</p>\n//\n// <p>This recovery strategy is implemented by {@link\n// //singleTokenInsertion}.</p>\n//\n// <p><strong>EXAMPLE</strong></p>\n//\n// <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When\n// the parser returns from the nested call to {@code expr}, it will have\n// call chain:</p>\n//\n// <pre>\n// stat &rarr; expr &rarr; atom\n// </pre>\n//\n// and it will be trying to match the {@code ')'} at this point in the\n// derivation:\n//\n// <pre>\n// =&gt; ID '=' '(' INT ')' ('+' atom)* ';'\n// ^\n// </pre>\n//\n// The attempt to match {@code ')'} will fail when it sees {@code ';'} and\n// call {@link //recoverInline}. To recover, it sees that {@code LA(1)==';'}\n// is in the set of tokens that can follow the {@code ')'} token reference\n// in rule {@code atom}. It can assume that you forgot the {@code ')'}.\n//\nDefaultErrorStrategy.prototype.recoverInline = function(recognizer) {\n    // SINGLE TOKEN DELETION\n    var matchedSymbol = this.singleTokenDeletion(recognizer);\n    if (matchedSymbol !== null) {\n        // we have deleted the extra token.\n        // now, move past ttype token as if all were ok\n        recognizer.consume();\n        return matchedSymbol;\n    }\n    // SINGLE TOKEN INSERTION\n    if (this.singleTokenInsertion(recognizer)) {\n        return this.getMissingSymbol(recognizer);\n    }\n    // even that didn't work; must throw the exception\n    throw new InputMismatchException(recognizer);\n};\n\n//\n// This method implements the single-token insertion inline error recovery\n// strategy. It is called by {@link //recoverInline} if the single-token\n// deletion strategy fails to recover from the mismatched input. If this\n// method returns {@code true}, {@code recognizer} will be in error recovery\n// mode.\n//\n// <p>This method determines whether or not single-token insertion is viable by\n// checking if the {@code LA(1)} input symbol could be successfully matched\n// if it were instead the {@code LA(2)} symbol. If this method returns\n// {@code true}, the caller is responsible for creating and inserting a\n// token with the correct type to produce this behavior.</p>\n//\n// @param recognizer the parser instance\n// @return {@code true} if single-token insertion is a viable recovery\n// strategy for the current mismatched input, otherwise {@code false}\n//\nDefaultErrorStrategy.prototype.singleTokenInsertion = function(recognizer) {\n    var currentSymbolType = recognizer.getTokenStream().LA(1);\n    // if current token is consistent with what could come after current\n    // ATN state, then we know we're missing a token; error recovery\n    // is free to conjure up and insert the missing token\n    var atn = recognizer._interp.atn;\n    var currentState = atn.states[recognizer.state];\n    var next = currentState.transitions[0].target;\n    var expectingAtLL2 = atn.nextTokens(next, recognizer._ctx);\n    if (expectingAtLL2.contains(currentSymbolType) ){\n        this.reportMissingToken(recognizer);\n        return true;\n    } else {\n        return false;\n    }\n};\n\n// This method implements the single-token deletion inline error recovery\n// strategy. It is called by {@link //recoverInline} to attempt to recover\n// from mismatched input. If this method returns null, the parser and error\n// handler state will not have changed. If this method returns non-null,\n// {@code recognizer} will <em>not</em> be in error recovery mode since the\n// returned token was a successful match.\n//\n// <p>If the single-token deletion is successful, this method calls\n// {@link //reportUnwantedToken} to report the error, followed by\n// {@link Parser//consume} to actually \"delete\" the extraneous token. Then,\n// before returning {@link //reportMatch} is called to signal a successful\n// match.</p>\n//\n// @param recognizer the parser instance\n// @return the successfully matched {@link Token} instance if single-token\n// deletion successfully recovers from the mismatched input, otherwise\n// {@code null}\n//\nDefaultErrorStrategy.prototype.singleTokenDeletion = function(recognizer) {\n    var nextTokenType = recognizer.getTokenStream().LA(2);\n    var expecting = this.getExpectedTokens(recognizer);\n    if (expecting.contains(nextTokenType)) {\n        this.reportUnwantedToken(recognizer);\n        // print(\"recoverFromMismatchedToken deleting \" \\\n        // + str(recognizer.getTokenStream().LT(1)) \\\n        // + \" since \" + str(recognizer.getTokenStream().LT(2)) \\\n        // + \" is what we want\", file=sys.stderr)\n        recognizer.consume(); // simply delete extra token\n        // we want to return the token we're actually matching\n        var matchedSymbol = recognizer.getCurrentToken();\n        this.reportMatch(recognizer); // we know current token is correct\n        return matchedSymbol;\n    } else {\n        return null;\n    }\n};\n\n// Conjure up a missing token during error recovery.\n//\n// The recognizer attempts to recover from single missing\n// symbols. But, actions might refer to that missing symbol.\n// For example, x=ID {f($x);}. The action clearly assumes\n// that there has been an identifier matched previously and that\n// $x points at that token. If that token is missing, but\n// the next token in the stream is what we want we assume that\n// this token is missing and we keep going. Because we\n// have to return some token to replace the missing token,\n// we have to conjure one up. This method gives the user control\n// over the tokens returned for missing tokens. Mostly,\n// you will want to create something special for identifier\n// tokens. For literals such as '{' and ',', the default\n// action in the parser or tree parser works. It simply creates\n// a CommonToken of the appropriate type. The text will be the token.\n// If you change what tokens must be created by the lexer,\n// override this method to create the appropriate tokens.\n//\nDefaultErrorStrategy.prototype.getMissingSymbol = function(recognizer) {\n    var currentSymbol = recognizer.getCurrentToken();\n    var expecting = this.getExpectedTokens(recognizer);\n    var expectedTokenType = expecting.first(); // get any element\n    var tokenText;\n    if (expectedTokenType===Token.EOF) {\n        tokenText = \"<missing EOF>\";\n    } else {\n        tokenText = \"<missing \" + recognizer.literalNames[expectedTokenType] + \">\";\n    }\n    var current = currentSymbol;\n    var lookback = recognizer.getTokenStream().LT(-1);\n    if (current.type===Token.EOF && lookback !== null) {\n        current = lookback;\n    }\n    return recognizer.getTokenFactory().create(current.source,\n        expectedTokenType, tokenText, Token.DEFAULT_CHANNEL,\n        -1, -1, current.line, current.column);\n};\n\nDefaultErrorStrategy.prototype.getExpectedTokens = function(recognizer) {\n    return recognizer.getExpectedTokens();\n};\n\n// How should a token be displayed in an error message? The default\n// is to display just the text, but during development you might\n// want to have a lot of information spit out. Override in that case\n// to use t.toString() (which, for CommonToken, dumps everything about\n// the token). This is better than forcing you to override a method in\n// your token objects because you don't have to go modify your lexer\n// so that it creates a new Java type.\n//\nDefaultErrorStrategy.prototype.getTokenErrorDisplay = function(t) {\n    if (t === null) {\n        return \"<no token>\";\n    }\n    var s = t.text;\n    if (s === null) {\n        if (t.type===Token.EOF) {\n            s = \"<EOF>\";\n        } else {\n            s = \"<\" + t.type + \">\";\n        }\n    }\n    return this.escapeWSAndQuote(s);\n};\n\nDefaultErrorStrategy.prototype.escapeWSAndQuote = function(s) {\n    s = s.replace(/\\n/g,\"\\\\n\");\n    s = s.replace(/\\r/g,\"\\\\r\");\n    s = s.replace(/\\t/g,\"\\\\t\");\n    return \"'\" + s + \"'\";\n};\n\n// Compute the error recovery set for the current rule. During\n// rule invocation, the parser pushes the set of tokens that can\n// follow that rule reference on the stack; this amounts to\n// computing FIRST of what follows the rule reference in the\n// enclosing rule. See LinearApproximator.FIRST().\n// This local follow set only includes tokens\n// from within the rule; i.e., the FIRST computation done by\n// ANTLR stops at the end of a rule.\n//\n// EXAMPLE\n//\n// When you find a \"no viable alt exception\", the input is not\n// consistent with any of the alternatives for rule r. The best\n// thing to do is to consume tokens until you see something that\n// can legally follow a call to r//or* any rule that called r.\n// You don't want the exact set of viable next tokens because the\n// input might just be missing a token--you might consume the\n// rest of the input looking for one of the missing tokens.\n//\n// Consider grammar:\n//\n// a : '[' b ']'\n// | '(' b ')'\n// ;\n// b : c '^' INT ;\n// c : ID\n// | INT\n// ;\n//\n// At each rule invocation, the set of tokens that could follow\n// that rule is pushed on a stack. Here are the various\n// context-sensitive follow sets:\n//\n// FOLLOW(b1_in_a) = FIRST(']') = ']'\n// FOLLOW(b2_in_a) = FIRST(')') = ')'\n// FOLLOW(c_in_b) = FIRST('^') = '^'\n//\n// Upon erroneous input \"[]\", the call chain is\n//\n// a -> b -> c\n//\n// and, hence, the follow context stack is:\n//\n// depth follow set start of rule execution\n// 0 <EOF> a (from main())\n// 1 ']' b\n// 2 '^' c\n//\n// Notice that ')' is not included, because b would have to have\n// been called from a different context in rule a for ')' to be\n// included.\n//\n// For error recovery, we cannot consider FOLLOW(c)\n// (context-sensitive or otherwise). We need the combined set of\n// all context-sensitive FOLLOW sets--the set of all tokens that\n// could follow any reference in the call chain. We need to\n// resync to one of those tokens. Note that FOLLOW(c)='^' and if\n// we resync'd to that token, we'd consume until EOF. We need to\n// sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.\n// In this case, for input \"[]\", LA(1) is ']' and in the set, so we would\n// not consume anything. After printing an error, rule c would\n// return normally. Rule b would not find the required '^' though.\n// At this point, it gets a mismatched token error and throws an\n// exception (since LA(1) is not in the viable following token\n// set). The rule exception handler tries to recover, but finds\n// the same recovery set and doesn't consume anything. Rule b\n// exits normally returning to rule a. Now it finds the ']' (and\n// with the successful match exits errorRecovery mode).\n//\n// So, you can see that the parser walks up the call chain looking\n// for the token that was a member of the recovery set.\n//\n// Errors are not generated in errorRecovery mode.\n//\n// ANTLR's error recovery mechanism is based upon original ideas:\n//\n// \"Algorithms + Data Structures = Programs\" by Niklaus Wirth\n//\n// and\n//\n// \"A note on error recovery in recursive descent parsers\":\n// http://portal.acm.org/citation.cfm?id=947902.947905\n//\n// Later, Josef Grosch had some good ideas:\n//\n// \"Efficient and Comfortable Error Recovery in Recursive Descent\n// Parsers\":\n// ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip\n//\n// Like Grosch I implement context-sensitive FOLLOW sets that are combined\n// at run-time upon error to avoid overhead during parsing.\n//\nDefaultErrorStrategy.prototype.getErrorRecoverySet = function(recognizer) {\n    var atn = recognizer._interp.atn;\n    var ctx = recognizer._ctx;\n    var recoverSet = new IntervalSet();\n    while (ctx !== null && ctx.invokingState>=0) {\n        // compute what follows who invoked us\n        var invokingState = atn.states[ctx.invokingState];\n        var rt = invokingState.transitions[0];\n        var follow = atn.nextTokens(rt.followState);\n        recoverSet.addSet(follow);\n        ctx = ctx.parentCtx;\n    }\n    recoverSet.removeOne(Token.EPSILON);\n    return recoverSet;\n};\n\n// Consume tokens until one matches the given token set.//\nDefaultErrorStrategy.prototype.consumeUntil = function(recognizer, set) {\n    var ttype = recognizer.getTokenStream().LA(1);\n    while( ttype !== Token.EOF && !set.contains(ttype)) {\n        recognizer.consume();\n        ttype = recognizer.getTokenStream().LA(1);\n    }\n};\n\n//\n// This implementation of {@link ANTLRErrorStrategy} responds to syntax errors\n// by immediately canceling the parse operation with a\n// {@link ParseCancellationException}. The implementation ensures that the\n// {@link ParserRuleContext//exception} field is set for all parse tree nodes\n// that were not completed prior to encountering the error.\n//\n// <p>\n// This error strategy is useful in the following scenarios.</p>\n//\n// <ul>\n// <li><strong>Two-stage parsing:</strong> This error strategy allows the first\n// stage of two-stage parsing to immediately terminate if an error is\n// encountered, and immediately fall back to the second stage. In addition to\n// avoiding wasted work by attempting to recover from errors here, the empty\n// implementation of {@link BailErrorStrategy//sync} improves the performance of\n// the first stage.</li>\n// <li><strong>Silent validation:</strong> When syntax errors are not being\n// reported or logged, and the parse result is simply ignored if errors occur,\n// the {@link BailErrorStrategy} avoids wasting work on recovering from errors\n// when the result will be ignored either way.</li>\n// </ul>\n//\n// <p>\n// {@code myparser.setErrorHandler(new BailErrorStrategy());}</p>\n//\n// @see Parser//setErrorHandler(ANTLRErrorStrategy)\n//\nfunction BailErrorStrategy() {\n\tDefaultErrorStrategy.call(this);\n\treturn this;\n}\n\nBailErrorStrategy.prototype = Object.create(DefaultErrorStrategy.prototype);\nBailErrorStrategy.prototype.constructor = BailErrorStrategy;\n\n// Instead of recovering from exception {@code e}, re-throw it wrapped\n// in a {@link ParseCancellationException} so it is not caught by the\n// rule function catches. Use {@link Exception//getCause()} to get the\n// original {@link RecognitionException}.\n//\nBailErrorStrategy.prototype.recover = function(recognizer, e) {\n    var context = recognizer._ctx;\n    while (context !== null) {\n        context.exception = e;\n        context = context.parentCtx;\n    }\n    throw new ParseCancellationException(e);\n};\n    \n// Make sure we don't attempt to recover inline; if the parser\n// successfully recovers, it won't throw an exception.\n//\nBailErrorStrategy.prototype.recoverInline = function(recognizer) {\n    this.recover(recognizer, new InputMismatchException(recognizer));\n};\n\n// Make sure we don't attempt to recover from problems in subrules.//\nBailErrorStrategy.prototype.sync = function(recognizer) {\n    // pass\n};\n\nexports.BailErrorStrategy = BailErrorStrategy;\nexports.DefaultErrorStrategy = DefaultErrorStrategy;\n},{\"./../IntervalSet\":6,\"./../Token\":14,\"./../atn/ATNState\":22,\"./Errors\":39}],39:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n// The root of the ANTLR exception hierarchy. In general, ANTLR tracks just\n//  3 kinds of errors: prediction errors, failed predicate errors, and\n//  mismatched input errors. In each case, the parser knows where it is\n//  in the input, where it is in the ATN, the rule invocation stack,\n//  and what kind of problem occurred.\n\nvar PredicateTransition = require('./../atn/Transition').PredicateTransition;\n\nfunction RecognitionException(params) {\n\tError.call(this);\n\tif (!!Error.captureStackTrace) {\n        Error.captureStackTrace(this, RecognitionException);\n\t} else {\n\t\tvar stack = new Error().stack;\n\t}\n\tthis.message = params.message;\n    this.recognizer = params.recognizer;\n    this.input = params.input;\n    this.ctx = params.ctx;\n    // The current {@link Token} when an error occurred. Since not all streams\n    // support accessing symbols by index, we have to track the {@link Token}\n    // instance itself.\n    this.offendingToken = null;\n    // Get the ATN state number the parser was in at the time the error\n    // occurred. For {@link NoViableAltException} and\n    // {@link LexerNoViableAltException} exceptions, this is the\n    // {@link DecisionState} number. For others, it is the state whose outgoing\n    // edge we couldn't match.\n    this.offendingState = -1;\n    if (this.recognizer!==null) {\n        this.offendingState = this.recognizer.state;\n    }\n    return this;\n}\n\nRecognitionException.prototype = Object.create(Error.prototype);\nRecognitionException.prototype.constructor = RecognitionException;\n\n// <p>If the state number is not known, this method returns -1.</p>\n\n//\n// Gets the set of input symbols which could potentially follow the\n// previously matched symbol at the time this exception was thrown.\n//\n// <p>If the set of expected tokens is not known and could not be computed,\n// this method returns {@code null}.</p>\n//\n// @return The set of token types that could potentially follow the current\n// state in the ATN, or {@code null} if the information is not available.\n// /\nRecognitionException.prototype.getExpectedTokens = function() {\n    if (this.recognizer!==null) {\n        return this.recognizer.atn.getExpectedTokens(this.offendingState, this.ctx);\n    } else {\n        return null;\n    }\n};\n\nRecognitionException.prototype.toString = function() {\n    return this.message;\n};\n\nfunction LexerNoViableAltException(lexer, input, startIndex, deadEndConfigs) {\n\tRecognitionException.call(this, {message:\"\", recognizer:lexer, input:input, ctx:null});\n    this.startIndex = startIndex;\n    this.deadEndConfigs = deadEndConfigs;\n    return this;\n}\n\nLexerNoViableAltException.prototype = Object.create(RecognitionException.prototype);\nLexerNoViableAltException.prototype.constructor = LexerNoViableAltException;\n\nLexerNoViableAltException.prototype.toString = function() {\n    var symbol = \"\";\n    if (this.startIndex >= 0 && this.startIndex < this.input.size) {\n        symbol = this.input.getText((this.startIndex,this.startIndex));\n    }\n    return \"LexerNoViableAltException\" + symbol;\n};\n\n// Indicates that the parser could not decide which of two or more paths\n// to take based upon the remaining input. It tracks the starting token\n// of the offending input and also knows where the parser was\n// in the various paths when the error. Reported by reportNoViableAlternative()\n//\nfunction NoViableAltException(recognizer, input, startToken, offendingToken, deadEndConfigs, ctx) {\n\tctx = ctx || recognizer._ctx;\n\toffendingToken = offendingToken || recognizer.getCurrentToken();\n\tstartToken = startToken || recognizer.getCurrentToken();\n\tinput = input || recognizer.getInputStream();\n\tRecognitionException.call(this, {message:\"\", recognizer:recognizer, input:input, ctx:ctx});\n    // Which configurations did we try at input.index() that couldn't match\n\t// input.LT(1)?//\n    this.deadEndConfigs = deadEndConfigs;\n    // The token object at the start index; the input stream might\n    // not be buffering tokens so get a reference to it. (At the\n    // time the error occurred, of course the stream needs to keep a\n    // buffer all of the tokens but later we might not have access to those.)\n    this.startToken = startToken;\n    this.offendingToken = offendingToken;\n}\n\nNoViableAltException.prototype = Object.create(RecognitionException.prototype);\nNoViableAltException.prototype.constructor = NoViableAltException;\n\n// This signifies any kind of mismatched input exceptions such as\n// when the current input does not match the expected token.\n//\nfunction InputMismatchException(recognizer) {\n\tRecognitionException.call(this, {message:\"\", recognizer:recognizer, input:recognizer.getInputStream(), ctx:recognizer._ctx});\n    this.offendingToken = recognizer.getCurrentToken();\n}\n\nInputMismatchException.prototype = Object.create(RecognitionException.prototype);\nInputMismatchException.prototype.constructor = InputMismatchException;\n\n// A semantic predicate failed during validation. Validation of predicates\n// occurs when normally parsing the alternative just like matching a token.\n// Disambiguating predicate evaluation occurs when we test a predicate during\n// prediction.\n\nfunction FailedPredicateException(recognizer, predicate, message) {\n\tRecognitionException.call(this, {message:this.formatMessage(predicate,message || null), recognizer:recognizer,\n                         input:recognizer.getInputStream(), ctx:recognizer._ctx});\n    var s = recognizer._interp.atn.states[recognizer.state];\n    var trans = s.transitions[0];\n    if (trans instanceof PredicateTransition) {\n        this.ruleIndex = trans.ruleIndex;\n        this.predicateIndex = trans.predIndex;\n    } else {\n        this.ruleIndex = 0;\n        this.predicateIndex = 0;\n    }\n    this.predicate = predicate;\n    this.offendingToken = recognizer.getCurrentToken();\n    return this;\n}\n\nFailedPredicateException.prototype = Object.create(RecognitionException.prototype);\nFailedPredicateException.prototype.constructor = FailedPredicateException;\n\nFailedPredicateException.prototype.formatMessage = function(predicate, message) {\n    if (message !==null) {\n        return message;\n    } else {\n        return \"failed predicate: {\" + predicate + \"}?\";\n    }\n};\n\nfunction ParseCancellationException() {\n\tError.call(this);\n\tError.captureStackTrace(this, ParseCancellationException);\n\treturn this;\n}\n\nParseCancellationException.prototype = Object.create(Error.prototype);\nParseCancellationException.prototype.constructor = ParseCancellationException;\n\nexports.RecognitionException = RecognitionException;\nexports.NoViableAltException = NoViableAltException;\nexports.LexerNoViableAltException = LexerNoViableAltException;\nexports.InputMismatchException = InputMismatchException;\nexports.FailedPredicateException = FailedPredicateException;\n\n},{\"./../atn/Transition\":30}],40:[function(require,module,exports){\nexports.RecognitionException = require('./Errors').RecognitionException;\nexports.NoViableAltException = require('./Errors').NoViableAltException;\nexports.LexerNoViableAltException = require('./Errors').LexerNoViableAltException;\nexports.InputMismatchException = require('./Errors').InputMismatchException;\nexports.FailedPredicateException = require('./Errors').FailedPredicateException;\nexports.DiagnosticErrorListener = require('./DiagnosticErrorListener').DiagnosticErrorListener;\nexports.BailErrorStrategy = require('./ErrorStrategy').BailErrorStrategy;\nexports.ErrorListener = require('./ErrorListener').ErrorListener;\n},{\"./DiagnosticErrorListener\":36,\"./ErrorListener\":37,\"./ErrorStrategy\":38,\"./Errors\":39}],41:[function(require,module,exports){\nexports.atn = require('./atn/index');\nexports.dfa = require('./dfa/index');\nexports.tree = require('./tree/index');\nexports.error = require('./error/index');\nexports.Token = require('./Token').Token;\nexports.CommonToken = require('./Token').CommonToken;\nexports.InputStream = require('./InputStream').InputStream;\nexports.FileStream = require('./FileStream').FileStream;\nexports.CommonTokenStream = require('./CommonTokenStream').CommonTokenStream;\nexports.Lexer = require('./Lexer').Lexer;\nexports.Parser = require('./Parser').Parser;\nvar pc = require('./PredictionContext');\nexports.PredictionContextCache = pc.PredictionContextCache;\nexports.ParserRuleContext = require('./ParserRuleContext').ParserRuleContext;\nexports.Interval = require('./IntervalSet').Interval;\nexports.Utils = require('./Utils');\n\n},{\"./CommonTokenStream\":3,\"./FileStream\":4,\"./InputStream\":5,\"./IntervalSet\":6,\"./Lexer\":8,\"./Parser\":9,\"./ParserRuleContext\":10,\"./PredictionContext\":11,\"./Token\":14,\"./Utils\":15,\"./atn/index\":31,\"./dfa/index\":35,\"./error/index\":40,\"./tree/index\":44}],42:[function(require,module,exports){\n// [The \"BSD license\"]\n//  Copyright (c) 2012 Terence Parr\n//  Copyright (c) 2012 Sam Harwell\n//  Copyright (c) 2014 Eric Vergnaud\n//  All rights reserved.\n//\n//  Redistribution and use in source and binary forms, with or without\n//  modification, are permitted provided that the following conditions\n//  are met:\n//\n//  1. Redistributions of source code must retain the above copyright\n//     notice, this list of conditions and the following disclaimer.\n//  2. Redistributions in binary form must reproduce the above copyright\n//     notice, this list of conditions and the following disclaimer in the\n//     documentation and/or other materials provided with the distribution.\n//  3. The name of the author may not be used to endorse or promote products\n//     derived from this software without specific prior written permission.\n//\n//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n//  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n//  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n//  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n///\n\n// The basic notion of a tree has a parent, a payload, and a list of children.\n//  It is the most abstract interface for all the trees used by ANTLR.\n///\n\nvar Token = require('./../Token').Token;\nvar Interval = require('./../IntervalSet').Interval;\nvar INVALID_INTERVAL = new Interval(-1, -2);\nvar Utils = require('../Utils.js');\n\n\nfunction Tree() {\n\treturn this;\n}\n\nfunction SyntaxTree() {\n\tTree.call(this);\n\treturn this;\n}\n\nSyntaxTree.prototype = Object.create(Tree.prototype);\nSyntaxTree.prototype.constructor = SyntaxTree;\n\nfunction ParseTree() {\n\tSyntaxTree.call(this);\n\treturn this;\n}\n\nParseTree.prototype = Object.create(SyntaxTree.prototype);\nParseTree.prototype.constructor = ParseTree;\n\nfunction RuleNode() {\n\tParseTree.call(this);\n\treturn this;\n}\n\nRuleNode.prototype = Object.create(ParseTree.prototype);\nRuleNode.prototype.constructor = RuleNode;\n\nfunction TerminalNode() {\n\tParseTree.call(this);\n\treturn this;\n}\n\nTerminalNode.prototype = Object.create(ParseTree.prototype);\nTerminalNode.prototype.constructor = TerminalNode;\n\nfunction ErrorNode() {\n\tTerminalNode.call(this);\n\treturn this;\n}\n\nErrorNode.prototype = Object.create(TerminalNode.prototype);\nErrorNode.prototype.constructor = ErrorNode;\n\nfunction ParseTreeVisitor() {\n\treturn this;\n}\n\nParseTreeVisitor.prototype.visit = function(ctx) {\n\tif (Utils.isArray(ctx)) {\n\t\tvar self = this;\n\t\treturn ctx.map(function(child) { return visitAtom(self, child)});\n\t} else {\n\t\treturn visitAtom(this, ctx);\n\t}\n};\n\nParseTreeVisitor.prototype.visitTerminal = function(node) {\n};\n\nParseTreeVisitor.prototype.visitErrorNode = function(node) {\n};\n\n\nvar visitAtom = function(visitor, ctx) {\n\tif (ctx.parser === undefined) { //is terminal\n\t\treturn;\n\t}\n\n\tvar name = ctx.parser.ruleNames[ctx.ruleIndex];\n\tvar funcName = \"visit\" + Utils.titleCase(name);\n\n\treturn visitor[funcName](ctx);\n};\n\nfunction ParseTreeListener() {\n\treturn this;\n}\n\nParseTreeListener.prototype.visitTerminal = function(node) {\n};\n\nParseTreeListener.prototype.visitErrorNode = function(node) {\n};\n\nParseTreeListener.prototype.enterEveryRule = function(node) {\n};\n\nParseTreeListener.prototype.exitEveryRule = function(node) {\n};\n\nfunction TerminalNodeImpl(symbol) {\n\tTerminalNode.call(this);\n\tthis.parentCtx = null;\n\tthis.symbol = symbol;\n\treturn this;\n}\n\nTerminalNodeImpl.prototype = Object.create(TerminalNode.prototype);\nTerminalNodeImpl.prototype.constructor = TerminalNodeImpl;\n\nTerminalNodeImpl.prototype.getChild = function(i) {\n\treturn null;\n};\n\nTerminalNodeImpl.prototype.getSymbol = function() {\n\treturn this.symbol;\n};\n\nTerminalNodeImpl.prototype.getParent = function() {\n\treturn this.parentCtx;\n};\n\nTerminalNodeImpl.prototype.getPayload = function() {\n\treturn this.symbol;\n};\n\nTerminalNodeImpl.prototype.getSourceInterval = function() {\n\tif (this.symbol === null) {\n\t\treturn INVALID_INTERVAL;\n\t}\n\tvar tokenIndex = this.symbol.tokenIndex;\n\treturn new Interval(tokenIndex, tokenIndex);\n};\n\nTerminalNodeImpl.prototype.getChildCount = function() {\n\treturn 0;\n};\n\nTerminalNodeImpl.prototype.accept = function(visitor) {\n\treturn visitor.visitTerminal(this);\n};\n\nTerminalNodeImpl.prototype.getText = function() {\n\treturn this.symbol.text;\n};\n\nTerminalNodeImpl.prototype.toString = function() {\n\tif (this.symbol.type === Token.EOF) {\n\t\treturn \"<EOF>\";\n\t} else {\n\t\treturn this.symbol.text;\n\t}\n};\n\n// Represents a token that was consumed during resynchronization\n// rather than during a valid match operation. For example,\n// we will create this kind of a node during single token insertion\n// and deletion as well as during \"consume until error recovery set\"\n// upon no viable alternative exceptions.\n\nfunction ErrorNodeImpl(token) {\n\tTerminalNodeImpl.call(this, token);\n\treturn this;\n}\n\nErrorNodeImpl.prototype = Object.create(TerminalNodeImpl.prototype);\nErrorNodeImpl.prototype.constructor = ErrorNodeImpl;\n\nErrorNodeImpl.prototype.isErrorNode = function() {\n\treturn true;\n};\n\nErrorNodeImpl.prototype.accept = function(visitor) {\n\treturn visitor.visitErrorNode(this);\n};\n\nfunction ParseTreeWalker() {\n\treturn this;\n}\n\nParseTreeWalker.prototype.walk = function(listener, t) {\n\tvar errorNode = t instanceof ErrorNode ||\n\t\t\t(t.isErrorNode !== undefined && t.isErrorNode());\n\tif (errorNode) {\n\t\tlistener.visitErrorNode(t);\n\t} else if (t instanceof TerminalNode) {\n\t\tlistener.visitTerminal(t);\n\t} else {\n\t\tthis.enterRule(listener, t);\n\t\tfor (var i = 0; i < t.getChildCount(); i++) {\n\t\t\tvar child = t.getChild(i);\n\t\t\tthis.walk(listener, child);\n\t\t}\n\t\tthis.exitRule(listener, t);\n\t}\n};\n//\n// The discovery of a rule node, involves sending two events: the generic\n// {@link ParseTreeListener//enterEveryRule} and a\n// {@link RuleContext}-specific event. First we trigger the generic and then\n// the rule specific. We to them in reverse order upon finishing the node.\n//\nParseTreeWalker.prototype.enterRule = function(listener, r) {\n\tvar ctx = r.getRuleContext();\n\tlistener.enterEveryRule(ctx);\n\tctx.enterRule(listener);\n};\n\nParseTreeWalker.prototype.exitRule = function(listener, r) {\n\tvar ctx = r.getRuleContext();\n\tctx.exitRule(listener);\n\tlistener.exitEveryRule(ctx);\n};\n\nParseTreeWalker.DEFAULT = new ParseTreeWalker();\n\nexports.RuleNode = RuleNode;\nexports.ErrorNode = ErrorNode;\nexports.TerminalNode = TerminalNode;\nexports.ErrorNodeImpl = ErrorNodeImpl;\nexports.TerminalNodeImpl = TerminalNodeImpl;\nexports.ParseTreeListener = ParseTreeListener;\nexports.ParseTreeVisitor = ParseTreeVisitor;\nexports.ParseTreeWalker = ParseTreeWalker;\nexports.INVALID_INTERVAL = INVALID_INTERVAL;\n},{\"../Utils.js\":15,\"./../IntervalSet\":6,\"./../Token\":14}],43:[function(require,module,exports){\n/*\n * [The \"BSD license\"]\n *  Copyright (c) 2012 Terence Parr\n *  Copyright (c) 2012 Sam Harwell\n *  All rights reserved.\n *\n *  Redistribution and use in source and binary forms, with or without\n *  modification, are permitted provided that the following conditions\n *  are met:\n *\n *  1. Redistributions of source code must retain the above copyright\n *     notice, this list of conditions and the following disclaimer.\n *  2. Redistributions in binary form must reproduce the above copyright\n *     notice, this list of conditions and the following disclaimer in the\n *     documentation and/or other materials provided with the distribution.\n *  3. The name of the author may not be used to endorse or promote products\n *     derived from this software without specific prior written permission.\n *\n *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nvar Utils = require('./../Utils');\nvar Token = require('./../Token').Token;\nvar RuleNode = require('./Tree').RuleNode;\nvar ErrorNode = require('./Tree').ErrorNode;\nvar TerminalNode = require('./Tree').TerminalNode;\nvar ParserRuleContext = require('./../ParserRuleContext').ParserRuleContext;\nvar RuleContext = require('./../RuleContext').RuleContext;\nvar INVALID_ALT_NUMBER = require('./../atn/ATN').INVALID_ALT_NUMBER;\n\n\n/** A set of utility routines useful for all kinds of ANTLR trees. */\nfunction Trees() {\n}\n\n// Print out a whole tree in LISP form. {@link //getNodeText} is used on the\n//  node payloads to get the text for the nodes.  Detect\n//  parse trees and extract data appropriately.\nTrees.toStringTree = function(tree, ruleNames, recog) {\n\truleNames = ruleNames || null;\n\trecog = recog || null;\n    if(recog!==null) {\n       ruleNames = recog.ruleNames;\n    }\n    var s = Trees.getNodeText(tree, ruleNames);\n    s = Utils.escapeWhitespace(s, false);\n    var c = tree.getChildCount();\n    if(c===0) {\n        return s;\n    }\n    var res = \"(\" + s + ' ';\n    if(c>0) {\n        s = Trees.toStringTree(tree.getChild(0), ruleNames);\n        res = res.concat(s);\n    }\n    for(var i=1;i<c;i++) {\n        s = Trees.toStringTree(tree.getChild(i), ruleNames);\n        res = res.concat(' ' + s);\n    }\n    res = res.concat(\")\");\n    return res;\n};\n\nTrees.getNodeText = function(t, ruleNames, recog) {\n\truleNames = ruleNames || null;\n\trecog = recog || null;\n    if(recog!==null) {\n        ruleNames = recog.ruleNames;\n    }\n    if(ruleNames!==null) {\n       if (t instanceof RuleContext) {\n           var altNumber = t.getAltNumber();\n           if ( altNumber!=INVALID_ALT_NUMBER ) {\n               return ruleNames[t.ruleIndex]+\":\"+altNumber;\n           }\n           return ruleNames[t.ruleIndex];\n       } else if ( t instanceof ErrorNode) {\n           return t.toString();\n       } else if(t instanceof TerminalNode) {\n           if(t.symbol!==null) {\n               return t.symbol.text;\n           }\n       }\n    }\n    // no recog for rule names\n    var payload = t.getPayload();\n    if (payload instanceof Token ) {\n       return payload.text;\n    }\n    return t.getPayload().toString();\n};\n\n\n// Return ordered list of all children of this node\nTrees.getChildren = function(t) {\n\tvar list = [];\n\tfor(var i=0;i<t.getChildCount();i++) {\n\t\tlist.push(t.getChild(i));\n\t}\n\treturn list;\n};\n\n// Return a list of all ancestors of this node.  The first node of\n//  list is the root and the last is the parent of this node.\n//\nTrees.getAncestors = function(t) {\n    var ancestors = [];\n    t = t.getParent();\n    while(t!==null) {\n        ancestors = [t].concat(ancestors);\n        t = t.getParent();\n    }\n    return ancestors;\n};\n\nTrees.findAllTokenNodes = function(t, ttype) {\n    return Trees.findAllNodes(t, ttype, true);\n};\n\nTrees.findAllRuleNodes = function(t, ruleIndex) {\n\treturn Trees.findAllNodes(t, ruleIndex, false);\n};\n\nTrees.findAllNodes = function(t, index, findTokens) {\n\tvar nodes = [];\n\tTrees._findAllNodes(t, index, findTokens, nodes);\n\treturn nodes;\n};\n\nTrees._findAllNodes = function(t, index, findTokens, nodes) {\n\t// check this node (the root) first\n\tif(findTokens && (t instanceof TerminalNode)) {\n\t\tif(t.symbol.type===index) {\n\t\t\tnodes.push(t);\n\t\t}\n\t} else if(!findTokens && (t instanceof ParserRuleContext)) {\n\t\tif(t.ruleIndex===index) {\n\t\t\tnodes.push(t);\n\t\t}\n\t}\n\t// check children\n\tfor(var i=0;i<t.getChildCount();i++) {\n\t\tTrees._findAllNodes(t.getChild(i), index, findTokens, nodes);\n\t}\n};\n\nTrees.descendants = function(t) {\n\tvar nodes = [t];\n    for(var i=0;i<t.getChildCount();i++) {\n        nodes = nodes.concat(Trees.descendants(t.getChild(i)));\n    }\n    return nodes;\n};\n\n\nexports.Trees = Trees;\n},{\"./../ParserRuleContext\":10,\"./../RuleContext\":13,\"./../Token\":14,\"./../Utils\":15,\"./../atn/ATN\":16,\"./Tree\":42}],44:[function(require,module,exports){\nvar Tree = require('./Tree');\nexports.Trees = require('./Trees').Trees;\nexports.RuleNode = Tree.RuleNode;\nexports.ParseTreeListener = Tree.ParseTreeListener;\nexports.ParseTreeVisitor = Tree.ParseTreeVisitor;\nexports.ParseTreeWalker = Tree.ParseTreeWalker;\n\n},{\"./Tree\":42,\"./Trees\":43}],45:[function(require,module,exports){\n\n},{}],46:[function(require,module,exports){\n'use strict';\n\nwindow.Smack = require('./compiler.js');\n},{\"./compiler.js\":47}],47:[function(require,module,exports){\n'use strict';\n\nvar antlr4 = require('antlr4');\nvar SmackLexer = require('./smack/SmackLexer').SmackLexer;\nvar SmackParser = require('./smack/SmackParser').SmackParser;\nvar compilers = require('./compilers');\nvar stdlib = require('./stdlib');\nvar g = require('./general');\n\nmodule.exports = (function () {\n\tvar createUnit = function createUnit(name, smkSource, targetSource, pack, funcNames, methodContext) {\n\t\tvar packParts = pack.split('.');\n\t\tvar packAbr = packParts[packParts.length - 1];\n\t\treturn {\n\t\t\tname: name,\n\t\t\tsmkSource: smkSource,\n\t\t\ttargetSource: targetSource,\n\t\t\tpack: pack,\n\t\t\tpackAbr: packAbr,\n\t\t\tfuncNames: funcNames,\n\t\t\tmethodContext: methodContext\n\t\t};\n\t};\n\n\tvar getParseTree = function getParseTree(source) {\n\t\tvar chars = new antlr4.InputStream(source);\n\t\tvar lexer = new SmackLexer(chars);\n\t\tvar tokens = new antlr4.CommonTokenStream(lexer);\n\t\tvar parser = new SmackParser(tokens);\n\t\tparser.buildParseTrees = true;\n\t\treturn parser.smkFile();\n\t};\n\n\tvar initMethodContext = function initMethodContext(ctx, methodContext) {\n\t\tif (!methodContext || typeof methodContext !== 'object') throw 'The method context must be an object';\n\t\t// Add the standard library if it's missing\n\t\tstdlib.extend(methodContext);\n\t\tvar packParts = compilers.getPackageParts(ctx.packageDecl(0));\n\t\tvar curObj = methodContext;\n\n\t\t// var noPackageErr = ncr().add('parts', \"throw \\\"package: \", pack, \" doesn\\'t exist\\\";\");\n\t\tg.validatePackageExists(packParts, methodContext);\n\t\t// eval(ncr().add('parts', \"try{ if(!methodContext.\", pack, \")\", noPackageErr, \"} catch(e) { \", noPackageErr, \" }\").format())\n\n\t\t// for(var i = 0; i < packParts.length; i++) {\n\t\t// \tif(!curObj[packParts[i]] || typeof curObj[packParts[i]] !== 'object')\n\t\t// \t\tcurObj[packParts[i]] = { _f : {} };\n\t\t// \tcurObj = curObj[packParts[i]];\n\t\t// }\n\t};\n\n\treturn {\n\t\tcreatePackage: g.createPackage,\n\t\tremovePackage: g.removePackage,\n\t\tcompile: function compile(name, smkSource, methodContext) {\n\t\t\tvar tree = getParseTree(smkSource);\n\t\t\tinitMethodContext(tree, methodContext);\n\t\t\tvar result = compilers.compileSmkFile(tree, methodContext);\n\t\t\tvar src = result.format();\n\t\t\teval(src);\n\t\t\treturn createUnit(name, smkSource, src, result.pack, result.funcNames, methodContext);\n\t\t}\n\t};\n})();\n},{\"./compilers\":48,\"./general\":49,\"./smack/SmackLexer\":51,\"./smack/SmackParser\":53,\"./stdlib\":55,\"antlr4\":41}],48:[function(require,module,exports){\n'use strict';\n\nvar SmackParser = require('./smack/SmackParser').SmackParser;\nvar jsGenerators = require('./jsGenerators');\n\nmodule.exports = (function () {\n\treturn {\n\t\tgetIds: function getIds(dottedId) {\n\t\t\tvar ids = [];\n\t\t\tfor (var i = 0; dottedId.Id(i); i++) ids.push(dottedId.Id(i).getText());\n\t\t\treturn ids;\n\t\t},\n\t\tgetPackageParts: function getPackageParts(ctx) {\n\t\t\treturn this.getIds(ctx.dottedId(0));\n\t\t},\n\t\tcompilePackageDecl: function compilePackageDecl(ctx) {\n\t\t\treturn jsGenerators.generatePackageDecl(this.getPackageParts(ctx));\n\t\t},\n\t\tcompileComment: function compileComment(ctx) {\n\t\t\treturn jsGenerators.generateComment(ctx.getText());\n\t\t},\n\t\tcompileValue: function compileValue(ctx) {\n\t\t\treturn jsGenerators.generateValue(ctx.getText());\n\t\t},\n\t\tcompileResolvable: function compileResolvable(ctx, pack, methodContext) {\n\t\t\tctx = ctx.children[0];\n\t\t\tif (ctx instanceof SmackParser.ValueContext) return this.compileValue(ctx);\n\t\t\tif (ctx instanceof SmackParser.JsonPathContext) return this.compileJsonPath(ctx, pack, methodContext);\n\t\t\tif (ctx instanceof SmackParser.FuncInvokeContext) return this.compileFuncInvoke(ctx, pack, methodContext);\n\t\t\tthrow 'Unhandled resolvable';\n\t\t},\n\t\tcompileKeyRef: function compileKeyRef(ctx, pack, methodContext) {\n\t\t\tvar resolvablePart = this.compileResolvable(ctx.resolvable(0), pack, methodContext);\n\t\t\treturn jsGenerators.generateKeyRef(resolvablePart);\n\t\t},\n\t\tcompileJsonPath: function compileJsonPath(ctx, pack, methodContext) {\n\t\t\tvar id = ctx.Id(0).getText();\n\t\t\tvar keyRefParts = [];\n\t\t\tfor (var i = 0; ctx.keyRef(i); i++) keyRefParts.push(this.compileKeyRef(ctx.keyRef(i), pack, methodContext));\n\t\t\treturn jsGenerators.generateJsonPath(id, keyRefParts);\n\t\t},\n\t\tcompileExpression: function compileExpression(ctx, pack, methodContext) {\n\t\t\tif (ctx instanceof SmackParser.AtomExprContext) return this.compileResolvable(ctx.resolvable(0), pack, methodContext);\n\t\t\tif (ctx instanceof SmackParser.SignedExprContext) return jsGenerators.generateSignedExpr(this.compileExpression(ctx.expression(0), pack, methodContext));\n\t\t\tif (ctx instanceof SmackParser.NotExprContext) return jsGenerators.generateNotExpr(this.compileExpression(ctx.expression(0), pack, methodContext));\n\t\t\tif (ctx instanceof SmackParser.ParenExprContext) return jsGenerators.generateParenExpr(this.compileExpression(ctx.expression(0), pack, methodContext));\n\t\t\tvar expr1Part = this.compileExpression(ctx.expression(0), pack, methodContext);\n\t\t\tvar expr2Part = this.compileExpression(ctx.expression(1), pack, methodContext);\n\t\t\tif (ctx instanceof SmackParser.SumExprContext) {\n\t\t\t\tvar isPos = true;\n\t\t\t\tfor (var i = 1; i < ctx.children.length; i++) {\n\t\t\t\t\tvar c = ctx.children[i];\n\t\t\t\t\tif (c.symbol && c.symbol.type === SmackParser.Minus) isPos = !isPos;\n\t\t\t\t}\n\t\t\t\tif (isPos) return jsGenerators.generatePlusExpr(expr1Part, expr2Part);else return jsGenerators.generateMinusExpr(expr1Part, expr2Part);\n\t\t\t}\n\t\t\tif (ctx instanceof SmackParser.PowExprContext) {\n\t\t\t\tif (ctx.expression(0) instanceof SmackParser.SignedExprContext) return jsGenerators.generateSignedPowExpr(this.compileExpression(ctx.expression(0).expression(0), pack, methodContext), expr2Part);\n\t\t\t\treturn jsGenerators.generatePowExpr(expr1Part, expr2Part);\n\t\t\t}\n\t\t\tif (ctx instanceof SmackParser.MulExprContext) return jsGenerators.generateMulExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.DivExprContext) return jsGenerators.generateDivExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.ModExprContext) return jsGenerators.generateModExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.EqExprContext) return jsGenerators.generateEqExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.NeqExprContext) return jsGenerators.generateNeqExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.LtExprContext) return jsGenerators.generateLtExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.LeExprContext) return jsGenerators.generateLeExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.GtExprContext) return jsGenerators.generateGtExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.GeExprContext) return jsGenerators.generateGeExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.AndExprContext) return jsGenerators.generateAndExpr(expr1Part, expr2Part);\n\t\t\tif (ctx instanceof SmackParser.OrExprContext) return jsGenerators.generateOrExpr(expr1Part, expr2Part);else throw 'Uhandled expression';\n\t\t},\n\t\tcompileVarAssign: function compileVarAssign(ctx, pack, methodContext) {\n\t\t\tvar jsonPathRes = this.compileJsonPath(ctx.jsonPath(0), pack, methodContext);\n\t\t\tvar expressionPart = this.compileExpression(ctx.expression(0), pack, methodContext);\n\t\t\treturn jsGenerators.generateVarAssign(jsonPathRes, expressionPart);\n\t\t},\n\t\tcompileFuncInvoke: function compileFuncInvoke(ctx, pack, methodContext) {\n\t\t\tvar ids = this.getIds(ctx.dottedId(0));\n\t\t\tvar resolvableParts = [];\n\t\t\tfor (var i = 0; ctx.resolvable(i); i++) resolvableParts.push(this.compileResolvable(ctx.resolvable(i), pack, methodContext));\n\t\t\treturn jsGenerators.generateFuncInvoke(pack, ids, resolvableParts, methodContext);\n\t\t},\n\t\tcompileRetStatement: function compileRetStatement(ctx, pack, methodContext) {\n\t\t\tvar expressionPart = this.compileExpression(ctx.expression(0), pack, methodContext);\n\t\t\treturn jsGenerators.generateRetStatement(expressionPart);\n\t\t},\n\t\tcompileStatement: function compileStatement(ctx, pack, methodContext) {\n\t\t\tvar statement = ctx.children[0];\n\t\t\tvar result;\n\t\t\tif (statement instanceof SmackParser.VarAssignContext) result = this.compileVarAssign(statement, pack, methodContext);else if (statement instanceof SmackParser.FuncInvokeContext) result = this.compileFuncInvoke(statement, pack, methodContext);else if (statement instanceof SmackParser.RetStatementContext) result = this.compileRetStatement(statement, pack, methodContext);\n\t\t\treturn jsGenerators.generateClosedStatement(result);\n\t\t},\n\t\tcompileLoop: function compileLoop(ctx, pack, methodContext) {\n\t\t\tvar expressionPart = this.compileExpression(ctx.expression(0), pack, methodContext);\n\t\t\tvar codeBlockPart = this.compileCodeBlock(ctx.codeBlock(0), pack, methodContext);\n\t\t\treturn jsGenerators.generateLoop(expressionPart, codeBlockPart);\n\t\t},\n\t\tcompileElseStat: function compileElseStat(ctx, pack, methodContext) {\n\t\t\tvar codeBlockPart = this.compileCodeBlock(ctx.codeBlock(0), pack, methodContext);\n\t\t\treturn jsGenerators.generateElseStat(codeBlockPart);\n\t\t},\n\t\tcompileElseIfStat: function compileElseIfStat(ctx, pack, methodContext) {\n\t\t\tvar expressionPart = this.compileExpression(ctx.expression(0), pack, methodContext);\n\t\t\tvar codeBlockPart = this.compileCodeBlock(ctx.codeBlock(0), pack, methodContext);\n\t\t\treturn jsGenerators.generateElseIfStat(expressionPart, codeBlockPart);\n\t\t},\n\t\tcompileIfStat: function compileIfStat(ctx, pack, methodContext) {\n\t\t\tvar expressionPart = this.compileExpression(ctx.expression(0), pack, methodContext);\n\t\t\tvar codeBlockPart = this.compileCodeBlock(ctx.codeBlock(0), pack, methodContext);\n\t\t\tvar elseifStatParts = [];\n\t\t\tfor (var i = 0; ctx.elseIfStat(i); i++) elseifStatParts.push(this.compileElseIfStat(ctx.elseIfStat(i), pack, methodContext));\n\t\t\tvar elseStatPart = '';\n\t\t\tif (ctx.elseStat(0)) elseStatPart = this.compileElseStat(ctx.elseStat(0), pack, methodContext);\n\t\t\treturn jsGenerators.generateIfStat(expressionPart, codeBlockPart, elseifStatParts, elseStatPart);\n\t\t},\n\t\tcompileSentence: function compileSentence(ctx, pack, methodContext) {\n\t\t\tvar sentence = ctx.children[0];\n\t\t\tvar src;\n\t\t\tif (sentence instanceof SmackParser.StatementContext) src = this.compileStatement(sentence, pack, methodContext);else if (sentence instanceof SmackParser.LoopContext) src = this.compileLoop(sentence, pack, methodContext);else if (sentence instanceof SmackParser.IfStatContext) src = this.compileIfStat(sentence, pack, methodContext);\n\t\t\treturn src;\n\t\t},\n\t\tcompileCodeBlock: function compileCodeBlock(ctx, pack, methodContext) {\n\t\t\tvar sentenceParts = [];\n\t\t\tfor (var i = 0; ctx.sentence(i); i++) sentenceParts.push(this.compileSentence(ctx.sentence(i), pack, methodContext));\n\t\t\treturn jsGenerators.generateCodeBlock(sentenceParts);\n\t\t},\n\t\tcompileFuncDecl: function compileFuncDecl(ctx, pack, methodContext) {\n\t\t\tvar codeBlockPart;\n\t\t\tvar ids = [];\n\n\t\t\tfor (var i = 0; i < ctx.children.length; i++) {\n\t\t\t\tvar c = ctx.children[i];\n\t\t\t\tif (c.symbol && c.symbol.type === SmackParser.Id) ids.push(c.getText());else if (c instanceof SmackParser.CodeBlockContext) codeBlockPart = this.compileCodeBlock(c, pack, methodContext);\n\t\t\t}\n\t\t\treturn jsGenerators.generateFuncDecl(pack, ids, codeBlockPart, methodContext);\n\t\t},\n\t\tcompileSmkFile: function compileSmkFile(ctx, methodContext) {\n\t\t\tvar pack = this.compilePackageDecl(ctx.packageDecl(0));\n\t\t\tvar funcNames = [];\n\t\t\tvar funcDeclParts = [];\n\t\t\tfor (var i = 0; i < ctx.children.length; i++) {\n\t\t\t\tvar c = ctx.children[i];\n\t\t\t\tif (c instanceof SmackParser.FuncDeclContext) {\n\t\t\t\t\tfuncDeclParts.push(this.compileFuncDecl(c, pack, methodContext));\n\t\t\t\t\tfuncNames.push(c.Id(0).getText());\n\t\t\t\t}\n\t\t\t}\n\t\t\tvar smkFileResult = jsGenerators.generateSmkFile(funcDeclParts, methodContext);\n\t\t\tsmkFileResult.pack = pack.format();\n\t\t\tsmkFileResult.funcNames = funcNames;\n\t\t\tsmkFileResult.methodContext = methodContext;\n\t\t\treturn smkFileResult;\n\t\t}\n\t};\n})();\n},{\"./jsGenerators\":50,\"./smack/SmackParser\":53}],49:[function(require,module,exports){\n'use strict';\n\nvar arrayFromArgs = function arrayFromArgs(args) {\n\tvar ary = [];\n\tfor (var i = 0; i < args.length; i++) ary.push(args[i]);\n\treturn ary;\n};\n\nmodule.exports = {\n\tvalidatePackageExists: function validatePackageExists(pack, methodContext) {\n\t\tif (typeof pack === 'string') pack = pack.split('.');\n\t\tvar curObj = methodContext;\n\t\tfor (var i = 0; i < pack.length; i++) if (!curObj[pack[i]] || typeof curObj[pack[i]] !== 'object') throw \"package: \" + pack.join('.') + \" doesn't exist\";\n\t},\n\tcreatePackage: function createPackage(pack, methodContext) {\n\t\tif (typeof pack === 'string') pack = pack.split('.');\n\t\tvar curObj = methodContext;\n\t\tfor (var i = 0; i < pack.length; i++) {\n\t\t\tif (!curObj[pack[i]] || typeof curObj[pack[i]] !== 'object') curObj[pack[i]] = { _f: {} };\n\t\t\tcurObj = curObj[pack[i]];\n\t\t}\n\t},\n\tremovePackage: function removePackage(pack, methodContext) {\n\t\tif (typeof pack === 'string') pack = pack.split('.');\n\t\tvar parent = null;\n\t\tvar curKey = null;\n\t\tvar curObj = methodContext;\n\t\tfor (var i = 0; i < pack.length; i++) {\n\t\t\tif (!curObj[pack[i]] || typeof curObj[pack[i]] !== 'object') return;\n\t\t\tparent = curObj;\n\t\t\tcurKey = pack[i];\n\t\t\tcurObj = parent[curKey];\n\t\t}\n\t\tdelete parent[curKey];\n\t},\n\tgetPackage: function getPackage(pack, methodContext) {\n\t\tif (typeof pack === 'string') pack = pack.split('.');\n\t\tvar curObj = methodContext;\n\t\tfor (var i = 0; i < pack.length; i++) {\n\t\t\tif (!curObj[pack[i]] || typeof curObj[pack[i]] !== 'object') curObj[pack[i]] = { _f: {} };\n\t\t\tcurObj = curObj[pack[i]];\n\t\t}\n\t\treturn curObj;\n\t},\n\tnewCompileResult: function newCompileResult() {\n\t\tvar set = function set(key, value) {\n\t\t\tthis[key] = value;\n\t\t\treturn this;\n\t\t};\n\n\t\tvar add = function add() {\n\t\t\tvar key = arguments[0];\n\t\t\tif (arguments.length > 1 && !this[key]) this[key] = [];\n\t\t\tfor (var i = 1; i < arguments.length; i++) {\n\t\t\t\tif (!arguments[i]) continue;\n\t\t\t\tif (Array.isArray(arguments[i])) this.add.apply(this, [key].concat(arguments[i]));else this[key].push(arguments[i]);\n\n\t\t\t\tif (typeof arguments[i] === 'object') moveParentScopeUpstream(this, arguments[i]);\n\t\t\t}\n\t\t\treturn this;\n\t\t};\n\n\t\tvar newParentScope = function newParentScope() {\n\t\t\treturn { set: set, add: add };\n\t\t};\n\n\t\tvar getParentScope = function getParentScope(ctx, type) {\n\t\t\tif (!ctx._parentScopes) ctx._parentScopes = {};\n\t\t\tif (!ctx._parentScopes[type]) ctx._parentScopes[type] = newParentScope();\n\t\t\treturn ctx._parentScopes[type];\n\t\t};\n\n\t\tvar moveParentScopeUpstream = function moveParentScopeUpstream(parent, child) {\n\t\t\tvar pcs = child._parentScopes;\n\t\t\tif (!pcs) return;\n\n\t\t\tfor (var type in pcs) {\n\t\t\t\tif (type === parent.type) copyAll(pcs[type], parent);else copyAll(pcs[type], getParentScope(parent, type));\n\t\t\t}\n\t\t\tchild._parentScopes = null;\n\t\t};\n\n\t\tvar copyAll = function copyAll(from, to) {\n\t\t\tfor (var key in from) {\n\t\t\t\tif (to.hasOwnProperty(key)) {\n\t\t\t\t\tif (Array.isArray(to[key])) to[key] = to[key].concat(from[key]);\n\t\t\t\t} else to[key] = from[key];\n\t\t\t}\n\t\t};\n\n\t\treturn {\n\t\t\tset: set,\n\t\t\tadd: add,\n\t\t\tsetToParent: function setToParent() {\n\t\t\t\tif (arguments.length < 2) return;\n\t\t\t\tvar pc = getParentScope(this, arguments[0]);\n\t\t\t\tpc.set(arguments[1], arguments[2]);\n\t\t\t},\n\t\t\taddToParent: function addToParent() {\n\t\t\t\tvar args = arrayFromArgs(arguments);\n\t\t\t\tif (args.length < 2) return;\n\t\t\t\tvar pc = getParentScope(this, args[0]);\n\t\t\t\tpc.add.apply(pc, args.slice(1));\n\t\t\t},\n\t\t\tformat: function format() {\n\t\t\t\tvar src = '';\n\t\t\t\tif (this.parts) for (var i = 0; i < this.parts.length; i++) src += typeof this.parts[i] === 'string' ? this.parts[i] : this.parts[i].format();\n\t\t\t\treturn src;\n\t\t\t}\n\t\t};\n\t},\n\tarrayFromArgs: arrayFromArgs,\n\tjoin: function join(ary, w) {\n\t\tvar res = [];\n\t\tfor (var i = 0; i < ary.length; i++) {\n\t\t\tres.push(ary[i]);\n\t\t\tif (i < ary.length - 1) res.push(w);\n\t\t}\n\t\treturn res;\n\t}\n};\n},{}],50:[function(require,module,exports){\n'use strict';\n\nvar g = require('./general');\nvar ncr = require('./general').newCompileResult;\n\nmodule.exports = (function () {\n\treturn {\n\t\tgenerateDottedId: function generateDottedId(ids) {\n\t\t\treturn ncr().add('parts', g.join(ids, '.'));\n\t\t},\n\t\tgeneratePackageDecl: function generatePackageDecl(ids) {\n\t\t\treturn this.generateDottedId(ids);\n\t\t},\n\t\tgenerateComment: function generateComment(str) {\n\t\t\treturn ' '; //'// ' + str + '\\n';\n\t\t},\n\t\tgenerateClosedStatement: function generateClosedStatement(openStatPart) {\n\t\t\treturn ncr().add('parts', openStatPart, ';');\n\t\t},\n\t\tgenerateVarDecl: function generateVarDecl(jsonPathPart) {\n\t\t\treturn ncr().add('parts', 'var ', jsonPathPart, ';');\n\t\t},\n\t\tgenerateVarDecls: function generateVarDecls(jsonPathParts, ids) {\n\t\t\tif (!jsonPathParts || jsonPathParts.length === 0) return '';\n\t\t\tvar cr = ncr();\n\t\t\tvar idMap = {};\n\t\t\tfor (var i = 0; i < ids; i++) idMap[ids[i]] = true;\n\t\t\tfor (var i = 0; i < jsonPathParts.length; i++) {\n\t\t\t\tvar name = jsonPathParts[i].format();\n\t\t\t\tif (!idMap[name]) cr.add('parts', 'var ', name, ';');\n\t\t\t}\n\t\t\treturn cr;\n\t\t},\n\t\tgenerateVarAssign: function generateVarAssign(jsonPathPart, expressionPart) {\n\t\t\tvar cr = ncr().add('parts', jsonPathPart, '=', expressionPart);\n\t\t\tif (jsonPathPart.isSimple) cr.addToParent('funcDecl', 'varDecl', jsonPathPart);\n\t\t\treturn cr;\n\t\t},\n\t\tgenerateValue: function generateValue(valueStr) {\n\t\t\treturn valueStr;\n\t\t},\n\t\tgenerateKeyRef: function generateKeyRef(resolvablePart) {\n\t\t\treturn ncr().add('parts', '[', resolvablePart, ']');\n\t\t},\n\t\tgenerateJsonPath: function generateJsonPath(id, keyRefParts) {\n\t\t\treturn ncr().set('isSimple', keyRefParts.length === 0).add('parts', id, keyRefParts);\n\t\t},\n\t\tgenerateSignedExpr: function generateSignedExpr(expressionPart) {\n\t\t\treturn ncr().add('parts', '-', expressionPart);\n\t\t},\n\t\tgenerateNotExpr: function generateNotExpr(expressionPart) {\n\t\t\treturn ncr().add('parts', '!', expressionPart);\n\t\t},\n\t\tgenerateParenExpr: function generateParenExpr(expressionPart) {\n\t\t\treturn ncr().add('parts', '(', expressionPart, ')');\n\t\t},\n\t\tgeneratePlusExpr: function generatePlusExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' + ', expr2Part);\n\t\t},\n\t\tgenerateMinusExpr: function generateMinusExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' - ', expr2Part);\n\t\t},\n\t\tgenerateMulExpr: function generateMulExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' * ', expr2Part);\n\t\t},\n\t\tgenerateDivExpr: function generateDivExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' / ', expr2Part);\n\t\t},\n\t\tgenerateModExpr: function generateModExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' % ', expr2Part);\n\t\t},\n\t\tgeneratePowExpr: function generatePowExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', 'Math.pow(', expr1Part, ', ', expr2Part, ')');\n\t\t},\n\t\tgenerateSignedPowExpr: function generateSignedPowExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', '-Math.pow(', expr1Part, ', ', expr2Part, ')');\n\t\t},\n\t\tgenerateEqExpr: function generateEqExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' === ', expr2Part);\n\t\t},\n\t\tgenerateNeqExpr: function generateNeqExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' !== ', expr2Part);\n\t\t},\n\t\tgenerateLtExpr: function generateLtExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' < ', expr2Part);\n\t\t},\n\t\tgenerateLeExpr: function generateLeExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' <= ', expr2Part);\n\t\t},\n\t\tgenerateGtExpr: function generateGtExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' > ', expr2Part);\n\t\t},\n\t\tgenerateGeExpr: function generateGeExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' >= ', expr2Part);\n\t\t},\n\t\tgenerateAndExpr: function generateAndExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' && ', expr2Part);\n\t\t},\n\t\tgenerateOrExpr: function generateOrExpr(expr1Part, expr2Part) {\n\t\t\treturn ncr().add('parts', expr1Part, ' || ', expr2Part);\n\t\t},\n\t\tgenerateFuncInvoke: function generateFuncInvoke(pack, ids, resolvableParts, methodContext) {\n\t\t\tvar cr = ncr().add('parts', 'methodContext.');\n\t\t\tif (ids.length > 1) cr.add('parts', g.join(ids.slice(0, ids.length - 1), '.'), '._f.', ids[ids.length - 1]);else if (methodContext._f[ids[0]]) cr.add('parts', '_f.', ids[0]);else cr.add('parts', pack, '._f.', ids[0]);\n\t\t\tcr.add('parts', '(', g.join(resolvableParts, ', '), ')');\n\t\t\treturn cr;\n\t\t},\n\t\tgenerateRetStatement: function generateRetStatement(expressionPart) {\n\t\t\treturn ncr().add('parts', 'return ', expressionPart);\n\t\t},\n\t\tgenerateLoop: function generateLoop(expressionPart, codeBlockPart) {\n\t\t\treturn ncr().add('parts', 'while', '(', expressionPart, ')', codeBlockPart);\n\t\t},\n\t\tgenerateElseStat: function generateElseStat(codeBlockPart) {\n\t\t\treturn ncr().add('parts', 'else', codeBlockPart);\n\t\t},\n\t\tgenerateElseIfStat: function generateElseIfStat(expressionPart, codeBlockPart) {\n\t\t\treturn ncr().add('parts', 'else if', '(', expressionPart, ')', codeBlockPart);\n\t\t},\n\t\tgenerateIfStat: function generateIfStat(expressionPart, codeBlockPart, elseifStatParts, elseStat) {\n\t\t\tvar cr = ncr().add('parts', 'if', '(', expressionPart, ')', codeBlockPart, elseifStatParts);\n\t\t\tif (elseStat) cr.add('parts', elseStat);\n\t\t\treturn cr;\n\t\t},\n\t\tgenerateCodeBlock: function generateCodeBlock(sentenceSources) {\n\t\t\tvar cr = ncr().add('parts', '{', sentenceSources, '}\\n');\n\t\t\tcr.addVarDecls = function () {\n\t\t\t\tthis.parts = ['{'].concat(g.arrayFromArgs(arguments)).concat(this.parts.slice(1));\n\t\t\t};\n\t\t\treturn cr;\n\t\t},\n\t\tgenerateFuncDecl: function generateFuncDecl(pack, ids, codeBlockPart, methodContext) {\n\t\t\tvar funcPath = ncr().add('parts', pack, '._f.', ids[0]);\n\t\t\tvar noPackageErr = ncr().add('parts', \"throw \\\"package: \", pack, \" doesn\\'t exist\\\";\");\n\t\t\tvar functionExistsErr = ncr().add('parts', 'throw \"the function ', funcPath, ' already exists\";');\n\t\t\teval(ncr().add('parts', \"try{ if(!methodContext.\", pack, \")\", noPackageErr, \"} catch(e) { \", noPackageErr, \" }\").format());\n\t\t\teval(ncr().add('parts', 'if(methodContext.', pack, ' && methodContext.', funcPath, ') ', functionExistsErr).format());\n\t\t\tvar cr = ncr().set('type', 'funcDecl').add('parts', codeBlockPart);\n\t\t\tcodeBlockPart.addVarDecls(this.generateVarDecls(cr.varDecl, ids));\n\t\t\tcr = ncr().add('parts', funcPath, ' = function(', g.join(ids.slice(1), ', '), ')', codeBlockPart);\n\t\t\treturn cr;\n\t\t},\n\t\tgenerateSmkFile: function generateSmkFile(funcDeclParts, methodContext) {\n\t\t\treturn ncr().add('parts', 'methodContext.', g.join(funcDeclParts, 'methodContext.'));\n\t\t}\n\t};\n})();\n},{\"./general\":49}],51:[function(require,module,exports){\n// Generated from ./Smack.g4 by ANTLR 4.5.3\n// jshint ignore: start\n\"use strict\";\n\nvar antlr4 = require('antlr4');\n\nvar serializedATN = [\"\\u0003а훑舆괭䐗껱趀ꫝ\", \"\\u0002*Ė\\b\\u0001\\u0004\\u0002\\t\\u0002\\u0004\\u0003\\t\\u0003\\u0004\", \"\\u0004\\t\\u0004\\u0004\\u0005\\t\\u0005\\u0004\\u0006\\t\\u0006\\u0004\\u0007\\t\", \"\\u0007\\u0004\\b\\t\\b\\u0004\\t\\t\\t\\u0004\\n\\t\\n\\u0004\\u000b\\t\\u000b\\u0004\", \"\\f\\t\\f\\u0004\\r\\t\\r\\u0004\\u000e\\t\\u000e\\u0004\\u000f\\t\\u000f\\u0004\\u0010\", \"\\t\\u0010\\u0004\\u0011\\t\\u0011\\u0004\\u0012\\t\\u0012\\u0004\\u0013\\t\\u0013\", \"\\u0004\\u0014\\t\\u0014\\u0004\\u0015\\t\\u0015\\u0004\\u0016\\t\\u0016\\u0004\\u0017\", \"\\t\\u0017\\u0004\\u0018\\t\\u0018\\u0004\\u0019\\t\\u0019\\u0004\\u001a\\t\\u001a\", \"\\u0004\\u001b\\t\\u001b\\u0004\\u001c\\t\\u001c\\u0004\\u001d\\t\\u001d\\u0004\\u001e\", \"\\t\\u001e\\u0004\\u001f\\t\\u001f\\u0004 \\t \\u0004!\\t!\\u0004\\\"\\t\\\"\\u0004#\", \"\\t#\\u0004$\\t$\\u0004%\\t%\\u0004&\\t&\\u0004'\\t'\\u0004(\\t(\\u0004)\\t)\\u0004\", \"*\\t*\\u0004+\\t+\\u0004,\\t,\\u0004-\\t-\\u0004.\\t.\\u0003\\u0002\\u0003\\u0002\", \"\\u0003\\u0002\\u0003\\u0002\\u0003\\u0002\\u0003\\u0003\\u0003\\u0003\\u0003\\u0004\", \"\\u0003\\u0004\\u0003\\u0005\\u0003\\u0005\\u0003\\u0005\\u0003\\u0005\\u0003\\u0005\", \"\\u0003\\u0006\\u0003\\u0006\\u0003\\u0007\\u0003\\u0007\\u0003\\b\\u0003\\b\\u0003\", \"\\t\\u0003\\t\\u0003\\n\\u0003\\n\\u0003\\u000b\\u0003\\u000b\\u0003\\f\\u0003\\f\\u0003\", \"\\f\\u0003\\f\\u0003\\r\\u0003\\r\\u0003\\r\\u0003\\u000e\\u0003\\u000e\\u0003\\u000e\", \"\\u0003\\u000e\\u0003\\u000e\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\", \"\\u0003\\u000f\\u0003\\u000f\\u0003\\u0010\\u0003\\u0010\\u0003\\u0011\\u0003\\u0011\", \"\\u0003\\u0012\\u0003\\u0012\\u0003\\u0013\\u0003\\u0013\\u0003\\u0013\\u0003\\u0013\", \"\\u0003\\u0013\\u0003\\u0014\\u0003\\u0014\\u0003\\u0014\\u0003\\u0014\\u0003\\u0014\", \"\\u0003\\u0014\\u0003\\u0015\\u0003\\u0015\\u0003\\u0015\\u0003\\u0015\\u0003\\u0015\", \"\\u0003\\u0016\\u0003\\u0016\\u0003\\u0017\\u0003\\u0017\\u0003\\u0018\\u0003\\u0018\", \"\\u0003\\u0019\\u0003\\u0019\\u0003\\u001a\\u0003\\u001a\\u0003\\u001b\\u0003\\u001b\", \"\\u0003\\u001c\\u0003\\u001c\\u0003\\u001d\\u0003\\u001d\\u0003\\u001d\\u0003\\u001e\", \"\\u0003\\u001e\\u0003\\u001e\\u0003\\u001f\\u0003\\u001f\\u0003 \\u0003 \\u0003\", \" \\u0003!\\u0003!\\u0003\\\"\\u0003\\\"\\u0003\\\"\\u0003#\\u0003#\\u0003#\\u0003$\", \"\\u0003$\\u0003$\\u0003%\\u0006%Å\\n%\\r%\\u000e%Æ\\u0003%\\u0007%\", \"Ê\\n%\\f%\\u000e%Í\\u000b%\\u0003&\\u0003&\\u0003&\\u0003&\\u0007&\", \"Ó\\n&\\f&\\u000e&Ö\\u000b&\\u0003&\\u0003&\\u0003&\\u0003&\\u0003'\", \"\\u0006'Ý\\n'\\r'\\u000e'Þ\\u0003'\\u0003'\\u0003(\\u0003(\\u0003\", \"(\\u0007(æ\\n(\\f(\\u000e(é\\u000b(\\u0003(\\u0003(\\u0003)\\u0003\", \")\\u0003)\\u0005)ð\\n)\\u0003*\\u0003*\\u0003*\\u0003*\\u0003*\\u0003*\\u0003\", \"+\\u0003+\\u0003,\\u0003,\\u0003,\\u0006,ý\\n,\\r,\\u000e,þ\\u0003\", \",\\u0005,Ă\\n,\\u0003,\\u0003,\\u0003,\\u0003,\\u0005,Ĉ\\n,\\u0003\", \"-\\u0003-\\u0003-\\u0007-č\\n-\\f-\\u000e-Đ\\u000b-\\u0005-Ē\", \"\\n-\\u0003.\\u0003.\\u0003.\\u0002\\u0002/\\u0003\\u0003\\u0005\\u0004\\u0007\", \"\\u0005\\t\\u0006\\u000b\\u0007\\r\\b\\u000f\\t\\u0011\\n\\u0013\\u000b\\u0015\\f\\u0017\", \"\\r\\u0019\\u000e\\u001b\\u000f\\u001d\\u0010\\u001f\\u0011!\\u0012#\\u0013%\\u0014\", \"'\\u0015)\\u0016+\\u0017-\\u0018/\\u00191\\u001a3\\u001b5\\u001c7\\u001d9\\u001e\", \";\\u001f= ?!A\\\"C#E$G%I&K'M(O)Q\\u0002S\\u0002U\\u0002W*Y\\u0002[\\u0002\\u0003\", \"\\u0002\\f\\u0006\\u0002&&C\\\\aac|\\u0007\\u0002&&2;C\\\\aac|\\u0003\\u0002\\f\\f\", \"\\u0005\\u0002\\u000b\\f\\u000f\\u000f\\\"\\\"\\u0004\\u0002$$^^\\n\\u0002$$11^^d\", \"dhhppttvv\\u0005\\u00022;CHch\\u0003\\u00022;\\u0003\\u00023;\\u0004\\u0002\", \"GGggĝ\\u0002\\u0003\\u0003\\u0002\\u0002\\u0002\\u0002\\u0005\\u0003\\u0002\", \"\\u0002\\u0002\\u0002\\u0007\\u0003\\u0002\\u0002\\u0002\\u0002\\t\\u0003\\u0002\", \"\\u0002\\u0002\\u0002\\u000b\\u0003\\u0002\\u0002\\u0002\\u0002\\r\\u0003\\u0002\", \"\\u0002\\u0002\\u0002\\u000f\\u0003\\u0002\\u0002\\u0002\\u0002\\u0011\\u0003\\u0002\", \"\\u0002\\u0002\\u0002\\u0013\\u0003\\u0002\\u0002\\u0002\\u0002\\u0015\\u0003\\u0002\", \"\\u0002\\u0002\\u0002\\u0017\\u0003\\u0002\\u0002\\u0002\\u0002\\u0019\\u0003\\u0002\", \"\\u0002\\u0002\\u0002\\u001b\\u0003\\u0002\\u0002\\u0002\\u0002\\u001d\\u0003\\u0002\", \"\\u0002\\u0002\\u0002\\u001f\\u0003\\u0002\\u0002\\u0002\\u0002!\\u0003\\u0002\", \"\\u0002\\u0002\\u0002#\\u0003\\u0002\\u0002\\u0002\\u0002%\\u0003\\u0002\\u0002\", \"\\u0002\\u0002'\\u0003\\u0002\\u0002\\u0002\\u0002)\\u0003\\u0002\\u0002\\u0002\", \"\\u0002+\\u0003\\u0002\\u0002\\u0002\\u0002-\\u0003\\u0002\\u0002\\u0002\\u0002\", \"/\\u0003\\u0002\\u0002\\u0002\\u00021\\u0003\\u0002\\u0002\\u0002\\u00023\\u0003\", \"\\u0002\\u0002\\u0002\\u00025\\u0003\\u0002\\u0002\\u0002\\u00027\\u0003\\u0002\", \"\\u0002\\u0002\\u00029\\u0003\\u0002\\u0002\\u0002\\u0002;\\u0003\\u0002\\u0002\", \"\\u0002\\u0002=\\u0003\\u0002\\u0002\\u0002\\u0002?\\u0003\\u0002\\u0002\\u0002\", \"\\u0002A\\u0003\\u0002\\u0002\\u0002\\u0002C\\u0003\\u0002\\u0002\\u0002\\u0002\", \"E\\u0003\\u0002\\u0002\\u0002\\u0002G\\u0003\\u0002\\u0002\\u0002\\u0002I\\u0003\", \"\\u0002\\u0002\\u0002\\u0002K\\u0003\\u0002\\u0002\\u0002\\u0002M\\u0003\\u0002\", \"\\u0002\\u0002\\u0002O\\u0003\\u0002\\u0002\\u0002\\u0002W\\u0003\\u0002\\u0002\", \"\\u0002\\u0003]\\u0003\\u0002\\u0002\\u0002\\u0005b\\u0003\\u0002\\u0002\\u0002\", \"\\u0007d\\u0003\\u0002\\u0002\\u0002\\tf\\u0003\\u0002\\u0002\\u0002\\u000bk\\u0003\", \"\\u0002\\u0002\\u0002\\rm\\u0003\\u0002\\u0002\\u0002\\u000fo\\u0003\\u0002\\u0002\", \"\\u0002\\u0011q\\u0003\\u0002\\u0002\\u0002\\u0013s\\u0003\\u0002\\u0002\\u0002\", \"\\u0015u\\u0003\\u0002\\u0002\\u0002\\u0017w\\u0003\\u0002\\u0002\\u0002\\u0019\", \"{\\u0003\\u0002\\u0002\\u0002\\u001b~\\u0003\\u0002\\u0002\\u0002\\u001dƒ\", \"\\u0003\\u0002\\u0002\\u0002\\u001f‰\\u0003\\u0002\\u0002\\u0002!‹\", \"\\u0003\\u0002\\u0002\\u0002#\\u0003\\u0002\\u0002\\u0002%\\u0003\", \"\\u0002\\u0002\\u0002'”\\u0003\\u0002\\u0002\\u0002)š\\u0003\\u0002\", \"\\u0002\\u0002+Ÿ\\u0003\\u0002\\u0002\\u0002-¡\\u0003\\u0002\\u0002\", \"\\u0002/£\\u0003\\u0002\\u0002\\u00021¥\\u0003\\u0002\\u0002\\u0002\", \"3§\\u0003\\u0002\\u0002\\u00025©\\u0003\\u0002\\u0002\\u00027«\", \"\\u0003\\u0002\\u0002\\u00029­\\u0003\\u0002\\u0002\\u0002;°\\u0003\", \"\\u0002\\u0002\\u0002=³\\u0003\\u0002\\u0002\\u0002?µ\\u0003\\u0002\", \"\\u0002\\u0002A¸\\u0003\\u0002\\u0002\\u0002Cº\\u0003\\u0002\\u0002\", \"\\u0002E½\\u0003\\u0002\\u0002\\u0002GÀ\\u0003\\u0002\\u0002\\u0002\", \"IÄ\\u0003\\u0002\\u0002\\u0002KÎ\\u0003\\u0002\\u0002\\u0002MÜ\", \"\\u0003\\u0002\\u0002\\u0002Oâ\\u0003\\u0002\\u0002\\u0002Qì\\u0003\", \"\\u0002\\u0002\\u0002Sñ\\u0003\\u0002\\u0002\\u0002U÷\\u0003\\u0002\", \"\\u0002\\u0002Wć\\u0003\\u0002\\u0002\\u0002Yđ\\u0003\\u0002\\u0002\", \"\\u0002[ē\\u0003\\u0002\\u0002\\u0002]^\\u0007r\\u0002\\u0002^_\\u0007c\", \"\\u0002\\u0002_`\\u0007e\\u0002\\u0002`a\\u0007m\\u0002\\u0002a\\u0004\\u0003\", \"\\u0002\\u0002\\u0002bc\\u0007=\\u0002\\u0002c\\u0006\\u0003\\u0002\\u0002\\u0002\", \"de\\u0007?\\u0002\\u0002e\\b\\u0003\\u0002\\u0002\\u0002fg\\u0007h\\u0002\\u0002\", \"gh\\u0007w\\u0002\\u0002hi\\u0007p\\u0002\\u0002ij\\u0007e\\u0002\\u0002j\\n\\u0003\", \"\\u0002\\u0002\\u0002kl\\u0007*\\u0002\\u0002l\\f\\u0003\\u0002\\u0002\\u0002m\", \"n\\u0007.\\u0002\\u0002n\\u000e\\u0003\\u0002\\u0002\\u0002op\\u0007+\\u0002\\u0002\", \"p\\u0010\\u0003\\u0002\\u0002\\u0002qr\\u00070\\u0002\\u0002r\\u0012\\u0003\\u0002\", \"\\u0002\\u0002st\\u0007]\\u0002\\u0002t\\u0014\\u0003\\u0002\\u0002\\u0002uv\\u0007\", \"_\\u0002\\u0002v\\u0016\\u0003\\u0002\\u0002\\u0002wx\\u0007t\\u0002\\u0002xy\", \"\\u0007g\\u0002\\u0002yz\\u0007v\\u0002\\u0002z\\u0018\\u0003\\u0002\\u0002\\u0002\", \"{|\\u0007k\\u0002\\u0002|}\\u0007h\\u0002\\u0002}\\u001a\\u0003\\u0002\\u0002\", \"\\u0002~\\u0007g\\u0002\\u0002€\\u0007n\\u0002\\u0002€\", \"\\u0007u\\u0002\\u0002‚\\u0007g\\u0002\\u0002‚\\u001c\", \"\\u0003\\u0002\\u0002\\u0002ƒ„\\u0007y\\u0002\\u0002„…\", \"\\u0007j\\u0002\\u0002…†\\u0007k\\u0002\\u0002†‡\\u0007\", \"n\\u0002\\u0002‡ˆ\\u0007g\\u0002\\u0002ˆ\\u001e\\u0003\\u0002\", \"\\u0002\\u0002‰Š\\u0007}\\u0002\\u0002Š \\u0003\\u0002\\u0002\", \"\\u0002‹Œ\\u0007\\u0002\\u0002Œ\\\"\\u0003\\u0002\\u0002\", \"\\u0002Ž\\u0007<\\u0002\\u0002Ž$\\u0003\\u0002\\u0002\\u0002\", \"\\u0007v\\u0002\\u0002‘\\u0007t\\u0002\\u0002‘\", \"’\\u0007w\\u0002\\u0002’“\\u0007g\\u0002\\u0002“&\\u0003\", \"\\u0002\\u0002\\u0002”•\\u0007h\\u0002\\u0002•–\\u0007\", \"c\\u0002\\u0002–—\\u0007n\\u0002\\u0002—˜\\u0007u\\u0002\", \"\\u0002˜™\\u0007g\\u0002\\u0002™(\\u0003\\u0002\\u0002\\u0002\", \"š›\\u0007p\\u0002\\u0002›œ\\u0007w\\u0002\\u0002œ\", \"\\u0007n\\u0002\\u0002ž\\u0007n\\u0002\\u0002ž*\\u0003\", \"\\u0002\\u0002\\u0002Ÿ \\u0007`\\u0002\\u0002 ,\\u0003\\u0002\", \"\\u0002\\u0002¡¢\\u0007,\\u0002\\u0002¢.\\u0003\\u0002\\u0002\", \"\\u0002£¤\\u00071\\u0002\\u0002¤0\\u0003\\u0002\\u0002\\u0002\", \"¥¦\\u0007'\\u0002\\u0002¦2\\u0003\\u0002\\u0002\\u0002§\", \"¨\\u0007-\\u0002\\u0002¨4\\u0003\\u0002\\u0002\\u0002©ª\", \"\\u0007/\\u0002\\u0002ª6\\u0003\\u0002\\u0002\\u0002«¬\\u0007\", \"#\\u0002\\u0002¬8\\u0003\\u0002\\u0002\\u0002­®\\u0007?\\u0002\", \"\\u0002®¯\\u0007?\\u0002\\u0002¯:\\u0003\\u0002\\u0002\\u0002\", \"°±\\u0007#\\u0002\\u0002±²\\u0007?\\u0002\\u0002²\", \"<\\u0003\\u0002\\u0002\\u0002³´\\u0007>\\u0002\\u0002´>\\u0003\", \"\\u0002\\u0002\\u0002µ¶\\u0007>\\u0002\\u0002¶·\\u0007\", \"?\\u0002\\u0002·@\\u0003\\u0002\\u0002\\u0002¸¹\\u0007@\\u0002\", \"\\u0002¹B\\u0003\\u0002\\u0002\\u0002º»\\u0007@\\u0002\\u0002\", \"»¼\\u0007?\\u0002\\u0002¼D\\u0003\\u0002\\u0002\\u0002½\", \"¾\\u0007(\\u0002\\u0002¾¿\\u0007(\\u0002\\u0002¿F\\u0003\", \"\\u0002\\u0002\\u0002ÀÁ\\u0007~\\u0002\\u0002ÁÂ\\u0007\", \"~\\u0002\\u0002ÂH\\u0003\\u0002\\u0002\\u0002ÃÅ\\t\\u0002\\u0002\", \"\\u0002ÄÃ\\u0003\\u0002\\u0002\\u0002ÅÆ\\u0003\\u0002\\u0002\", \"\\u0002ÆÄ\\u0003\\u0002\\u0002\\u0002ÆÇ\\u0003\\u0002\\u0002\", \"\\u0002ÇË\\u0003\\u0002\\u0002\\u0002ÈÊ\\t\\u0003\\u0002\", \"\\u0002ÉÈ\\u0003\\u0002\\u0002\\u0002ÊÍ\\u0003\\u0002\\u0002\", \"\\u0002ËÉ\\u0003\\u0002\\u0002\\u0002ËÌ\\u0003\\u0002\\u0002\", \"\\u0002ÌJ\\u0003\\u0002\\u0002\\u0002ÍË\\u0003\\u0002\\u0002\", \"\\u0002ÎÏ\\u00071\\u0002\\u0002ÏÐ\\u00071\\u0002\\u0002\", \"ÐÔ\\u0003\\u0002\\u0002\\u0002ÑÓ\\n\\u0004\\u0002\\u0002\", \"ÒÑ\\u0003\\u0002\\u0002\\u0002ÓÖ\\u0003\\u0002\\u0002\\u0002\", \"ÔÒ\\u0003\\u0002\\u0002\\u0002ÔÕ\\u0003\\u0002\\u0002\\u0002\", \"Õ×\\u0003\\u0002\\u0002\\u0002ÖÔ\\u0003\\u0002\\u0002\\u0002\", \"×Ø\\u0007\\f\\u0002\\u0002ØÙ\\u0003\\u0002\\u0002\\u0002\", \"ÙÚ\\b&\\u0002\\u0002ÚL\\u0003\\u0002\\u0002\\u0002ÛÝ\", \"\\t\\u0005\\u0002\\u0002ÜÛ\\u0003\\u0002\\u0002\\u0002ÝÞ\", \"\\u0003\\u0002\\u0002\\u0002ÞÜ\\u0003\\u0002\\u0002\\u0002Þß\", \"\\u0003\\u0002\\u0002\\u0002ßà\\u0003\\u0002\\u0002\\u0002àá\", \"\\b'\\u0002\\u0002áN\\u0003\\u0002\\u0002\\u0002âç\\u0007$\\u0002\", \"\\u0002ãæ\\u0005Q)\\u0002äæ\\n\\u0006\\u0002\\u0002å\", \"ã\\u0003\\u0002\\u0002\\u0002åä\\u0003\\u0002\\u0002\\u0002æ\", \"é\\u0003\\u0002\\u0002\\u0002çå\\u0003\\u0002\\u0002\\u0002ç\", \"è\\u0003\\u0002\\u0002\\u0002èê\\u0003\\u0002\\u0002\\u0002é\", \"ç\\u0003\\u0002\\u0002\\u0002êë\\u0007$\\u0002\\u0002ë\", \"P\\u0003\\u0002\\u0002\\u0002ìï\\u0007^\\u0002\\u0002íð\", \"\\t\\u0007\\u0002\\u0002îð\\u0005S*\\u0002ïí\\u0003\\u0002\", \"\\u0002\\u0002ïî\\u0003\\u0002\\u0002\\u0002ðR\\u0003\\u0002\", \"\\u0002\\u0002ñò\\u0007w\\u0002\\u0002òó\\u0005U+\\u0002\", \"óô\\u0005U+\\u0002ôõ\\u0005U+\\u0002õö\\u0005\", \"U+\\u0002öT\\u0003\\u0002\\u0002\\u0002÷ø\\t\\b\\u0002\\u0002\", \"øV\\u0003\\u0002\\u0002\\u0002ùú\\u0005Y-\\u0002úü\", \"\\u00070\\u0002\\u0002ûý\\t\\t\\u0002\\u0002üû\\u0003\\u0002\", \"\\u0002\\u0002ýþ\\u0003\\u0002\\u0002\\u0002þü\\u0003\\u0002\", \"\\u0002\\u0002þÿ\\u0003\\u0002\\u0002\\u0002ÿā\\u0003\\u0002\", \"\\u0002\\u0002ĀĂ\\u0005[.\\u0002āĀ\\u0003\\u0002\\u0002\", \"\\u0002āĂ\\u0003\\u0002\\u0002\\u0002ĂĈ\\u0003\\u0002\\u0002\", \"\\u0002ăĄ\\u0005Y-\\u0002Ąą\\u0005[.\\u0002ąĈ\", \"\\u0003\\u0002\\u0002\\u0002ĆĈ\\u0005Y-\\u0002ćù\\u0003\", \"\\u0002\\u0002\\u0002ćă\\u0003\\u0002\\u0002\\u0002ćĆ\\u0003\", \"\\u0002\\u0002\\u0002ĈX\\u0003\\u0002\\u0002\\u0002ĉĒ\\u0007\", \"2\\u0002\\u0002ĊĎ\\t\\n\\u0002\\u0002ċč\\t\\t\\u0002\\u0002\", \"Čċ\\u0003\\u0002\\u0002\\u0002čĐ\\u0003\\u0002\\u0002\\u0002\", \"ĎČ\\u0003\\u0002\\u0002\\u0002Ďď\\u0003\\u0002\\u0002\\u0002\", \"ďĒ\\u0003\\u0002\\u0002\\u0002ĐĎ\\u0003\\u0002\\u0002\\u0002\", \"đĉ\\u0003\\u0002\\u0002\\u0002đĊ\\u0003\\u0002\\u0002\\u0002\", \"ĒZ\\u0003\\u0002\\u0002\\u0002ēĔ\\t\\u000b\\u0002\\u0002Ĕ\", \"ĕ\\u0005Y-\\u0002ĕ\\\\\\u0003\\u0002\\u0002\\u0002\\u000f\\u0002Æ\", \"ËÔÞåçïþāćĎđ\\u0003\", \"\\b\\u0002\\u0002\"].join(\"\");\n\nvar atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);\n\nvar decisionsToDFA = atn.decisionToState.map(function (ds, index) {\n    return new antlr4.dfa.DFA(ds, index);\n});\n\nfunction SmackLexer(input) {\n    antlr4.Lexer.call(this, input);\n    this._interp = new antlr4.atn.LexerATNSimulator(this, atn, decisionsToDFA, new antlr4.PredictionContextCache());\n    return this;\n}\n\nSmackLexer.prototype = Object.create(antlr4.Lexer.prototype);\nSmackLexer.prototype.constructor = SmackLexer;\n\nSmackLexer.EOF = antlr4.Token.EOF;\nSmackLexer.T__0 = 1;\nSmackLexer.T__1 = 2;\nSmackLexer.T__2 = 3;\nSmackLexer.T__3 = 4;\nSmackLexer.T__4 = 5;\nSmackLexer.T__5 = 6;\nSmackLexer.T__6 = 7;\nSmackLexer.T__7 = 8;\nSmackLexer.T__8 = 9;\nSmackLexer.T__9 = 10;\nSmackLexer.T__10 = 11;\nSmackLexer.T__11 = 12;\nSmackLexer.T__12 = 13;\nSmackLexer.T__13 = 14;\nSmackLexer.T__14 = 15;\nSmackLexer.T__15 = 16;\nSmackLexer.T__16 = 17;\nSmackLexer.T__17 = 18;\nSmackLexer.T__18 = 19;\nSmackLexer.T__19 = 20;\nSmackLexer.Pow = 21;\nSmackLexer.Mul = 22;\nSmackLexer.Div = 23;\nSmackLexer.Mod = 24;\nSmackLexer.Plus = 25;\nSmackLexer.Minus = 26;\nSmackLexer.Not = 27;\nSmackLexer.Eq = 28;\nSmackLexer.Neq = 29;\nSmackLexer.Lt = 30;\nSmackLexer.Le = 31;\nSmackLexer.Gt = 32;\nSmackLexer.Ge = 33;\nSmackLexer.And = 34;\nSmackLexer.Or = 35;\nSmackLexer.Id = 36;\nSmackLexer.Comment = 37;\nSmackLexer.WS = 38;\nSmackLexer.STRING = 39;\nSmackLexer.NUMBER = 40;\n\nSmackLexer.modeNames = [\"DEFAULT_MODE\"];\n\nSmackLexer.literalNames = [null, \"'pack'\", \"';'\", \"'='\", \"'func'\", \"'('\", \"','\", \"')'\", \"'.'\", \"'['\", \"']'\", \"'ret'\", \"'if'\", \"'else'\", \"'while'\", \"'{'\", \"'}'\", \"':'\", \"'true'\", \"'false'\", \"'null'\", \"'^'\", \"'*'\", \"'/'\", \"'%'\", \"'+'\", \"'-'\", \"'!'\", \"'=='\", \"'!='\", \"'<'\", \"'<='\", \"'>'\", \"'>='\", \"'&&'\", \"'||'\"];\n\nSmackLexer.symbolicNames = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, \"Pow\", \"Mul\", \"Div\", \"Mod\", \"Plus\", \"Minus\", \"Not\", \"Eq\", \"Neq\", \"Lt\", \"Le\", \"Gt\", \"Ge\", \"And\", \"Or\", \"Id\", \"Comment\", \"WS\", \"STRING\", \"NUMBER\"];\n\nSmackLexer.ruleNames = [\"T__0\", \"T__1\", \"T__2\", \"T__3\", \"T__4\", \"T__5\", \"T__6\", \"T__7\", \"T__8\", \"T__9\", \"T__10\", \"T__11\", \"T__12\", \"T__13\", \"T__14\", \"T__15\", \"T__16\", \"T__17\", \"T__18\", \"T__19\", \"Pow\", \"Mul\", \"Div\", \"Mod\", \"Plus\", \"Minus\", \"Not\", \"Eq\", \"Neq\", \"Lt\", \"Le\", \"Gt\", \"Ge\", \"And\", \"Or\", \"Id\", \"Comment\", \"WS\", \"STRING\", \"ESC\", \"UNICODE\", \"HEX\", \"NUMBER\", \"INT\", \"EXP\"];\n\nSmackLexer.grammarFileName = \"Smack.g4\";\n\nexports.SmackLexer = SmackLexer;\n},{\"antlr4\":41}],52:[function(require,module,exports){\n// Generated from ./Smack.g4 by ANTLR 4.5.3\n// jshint ignore: start\n'use strict';\n\nvar antlr4 = require('antlr4');\n\n// This class defines a complete listener for a parse tree produced by SmackParser.\nfunction SmackListener() {\n\tantlr4.tree.ParseTreeListener.call(this);\n\treturn this;\n}\n\nSmackListener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype);\nSmackListener.prototype.constructor = SmackListener;\n\n// Enter a parse tree produced by SmackParser#smkFile.\nSmackListener.prototype.enterSmkFile = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#smkFile.\nSmackListener.prototype.exitSmkFile = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#packageDecl.\nSmackListener.prototype.enterPackageDecl = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#packageDecl.\nSmackListener.prototype.exitPackageDecl = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#varAssign.\nSmackListener.prototype.enterVarAssign = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#varAssign.\nSmackListener.prototype.exitVarAssign = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#funcDecl.\nSmackListener.prototype.enterFuncDecl = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#funcDecl.\nSmackListener.prototype.exitFuncDecl = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#funcInvoke.\nSmackListener.prototype.enterFuncInvoke = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#funcInvoke.\nSmackListener.prototype.exitFuncInvoke = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#jsonPath.\nSmackListener.prototype.enterJsonPath = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#jsonPath.\nSmackListener.prototype.exitJsonPath = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#dottedId.\nSmackListener.prototype.enterDottedId = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#dottedId.\nSmackListener.prototype.exitDottedId = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#keyRef.\nSmackListener.prototype.enterKeyRef = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#keyRef.\nSmackListener.prototype.exitKeyRef = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#retStatement.\nSmackListener.prototype.enterRetStatement = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#retStatement.\nSmackListener.prototype.exitRetStatement = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#ifStat.\nSmackListener.prototype.enterIfStat = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#ifStat.\nSmackListener.prototype.exitIfStat = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#elseIfStat.\nSmackListener.prototype.enterElseIfStat = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#elseIfStat.\nSmackListener.prototype.exitElseIfStat = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#elseStat.\nSmackListener.prototype.enterElseStat = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#elseStat.\nSmackListener.prototype.exitElseStat = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#loop.\nSmackListener.prototype.enterLoop = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#loop.\nSmackListener.prototype.exitLoop = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#signedExpr.\nSmackListener.prototype.enterSignedExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#signedExpr.\nSmackListener.prototype.exitSignedExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#geExpr.\nSmackListener.prototype.enterGeExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#geExpr.\nSmackListener.prototype.exitGeExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#modExpr.\nSmackListener.prototype.enterModExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#modExpr.\nSmackListener.prototype.exitModExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#gtExpr.\nSmackListener.prototype.enterGtExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#gtExpr.\nSmackListener.prototype.exitGtExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#atomExpr.\nSmackListener.prototype.enterAtomExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#atomExpr.\nSmackListener.prototype.exitAtomExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#orExpr.\nSmackListener.prototype.enterOrExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#orExpr.\nSmackListener.prototype.exitOrExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#parenExpr.\nSmackListener.prototype.enterParenExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#parenExpr.\nSmackListener.prototype.exitParenExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#neqExpr.\nSmackListener.prototype.enterNeqExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#neqExpr.\nSmackListener.prototype.exitNeqExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#eqExpr.\nSmackListener.prototype.enterEqExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#eqExpr.\nSmackListener.prototype.exitEqExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#ltExpr.\nSmackListener.prototype.enterLtExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#ltExpr.\nSmackListener.prototype.exitLtExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#notExpr.\nSmackListener.prototype.enterNotExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#notExpr.\nSmackListener.prototype.exitNotExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#sumExpr.\nSmackListener.prototype.enterSumExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#sumExpr.\nSmackListener.prototype.exitSumExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#leExpr.\nSmackListener.prototype.enterLeExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#leExpr.\nSmackListener.prototype.exitLeExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#mulExpr.\nSmackListener.prototype.enterMulExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#mulExpr.\nSmackListener.prototype.exitMulExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#divExpr.\nSmackListener.prototype.enterDivExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#divExpr.\nSmackListener.prototype.exitDivExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#powExpr.\nSmackListener.prototype.enterPowExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#powExpr.\nSmackListener.prototype.exitPowExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#andExpr.\nSmackListener.prototype.enterAndExpr = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#andExpr.\nSmackListener.prototype.exitAndExpr = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#resolvable.\nSmackListener.prototype.enterResolvable = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#resolvable.\nSmackListener.prototype.exitResolvable = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#codeBlock.\nSmackListener.prototype.enterCodeBlock = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#codeBlock.\nSmackListener.prototype.exitCodeBlock = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#sentence.\nSmackListener.prototype.enterSentence = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#sentence.\nSmackListener.prototype.exitSentence = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#statement.\nSmackListener.prototype.enterStatement = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#statement.\nSmackListener.prototype.exitStatement = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#json.\nSmackListener.prototype.enterJson = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#json.\nSmackListener.prototype.exitJson = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#object.\nSmackListener.prototype.enterObject = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#object.\nSmackListener.prototype.exitObject = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#pair.\nSmackListener.prototype.enterPair = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#pair.\nSmackListener.prototype.exitPair = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#array.\nSmackListener.prototype.enterArray = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#array.\nSmackListener.prototype.exitArray = function (ctx) {};\n\n// Enter a parse tree produced by SmackParser#value.\nSmackListener.prototype.enterValue = function (ctx) {};\n\n// Exit a parse tree produced by SmackParser#value.\nSmackListener.prototype.exitValue = function (ctx) {};\n\nexports.SmackListener = SmackListener;\n},{\"antlr4\":41}],53:[function(require,module,exports){\n// Generated from ./Smack.g4 by ANTLR 4.5.3\n// jshint ignore: start\n'use strict';var antlr4=require('antlr4');var SmackListener=require('./SmackListener').SmackListener;var SmackVisitor=require('./SmackVisitor').SmackVisitor;var grammarFileName=\"Smack.g4\";var serializedATN=['\\u0003а훑舆괭䐗껱趀ꫝ','\\u0003*ė\\u0004\\u0002\\t\\u0002\\u0004\\u0003\\t\\u0003\\u0004\\u0004\\t','\\u0004\\u0004\\u0005\\t\\u0005\\u0004\\u0006\\t\\u0006\\u0004\\u0007\\t\\u0007\\u0004','\\b\\t\\b\\u0004\\t\\t\\t\\u0004\\n\\t\\n\\u0004\\u000b\\t\\u000b\\u0004\\f\\t\\f\\u0004','\\r\\t\\r\\u0004\\u000e\\t\\u000e\\u0004\\u000f\\t\\u000f\\u0004\\u0010\\t\\u0010\\u0004','\\u0011\\t\\u0011\\u0004\\u0012\\t\\u0012\\u0004\\u0013\\t\\u0013\\u0004\\u0014\\t','\\u0014\\u0004\\u0015\\t\\u0015\\u0004\\u0016\\t\\u0016\\u0004\\u0017\\t\\u0017\\u0004','\\u0018\\t\\u0018\\u0003\\u0002\\u0003\\u0002\\u0007\\u00023\\n\\u0002\\f\\u0002','\\u000e\\u00026\\u000b\\u0002\\u0003\\u0003\\u0003\\u0003\\u0003\\u0003\\u0003','\\u0003\\u0003\\u0004\\u0003\\u0004\\u0003\\u0004\\u0003\\u0004\\u0003\\u0005\\u0003','\\u0005\\u0003\\u0005\\u0003\\u0005\\u0005\\u0005D\\n\\u0005\\u0003\\u0005\\u0003','\\u0005\\u0007\\u0005H\\n\\u0005\\f\\u0005\\u000e\\u0005K\\u000b\\u0005\\u0003\\u0005','\\u0003\\u0005\\u0003\\u0005\\u0003\\u0006\\u0003\\u0006\\u0003\\u0006\\u0005\\u0006','S\\n\\u0006\\u0003\\u0006\\u0003\\u0006\\u0007\\u0006W\\n\\u0006\\f\\u0006\\u000e','\\u0006Z\\u000b\\u0006\\u0003\\u0006\\u0003\\u0006\\u0003\\u0007\\u0003\\u0007','\\u0007\\u0007`\\n\\u0007\\f\\u0007\\u000e\\u0007c\\u000b\\u0007\\u0003\\b\\u0003','\\b\\u0003\\b\\u0007\\bh\\n\\b\\f\\b\\u000e\\bk\\u000b\\b\\u0003\\t\\u0003\\t\\u0003\\t','\\u0003\\t\\u0003\\n\\u0003\\n\\u0003\\n\\u0003\\u000b\\u0003\\u000b\\u0003\\u000b','\\u0003\\u000b\\u0003\\u000b\\u0003\\u000b\\u0007\\u000bz\\n\\u000b\\f\\u000b\\u000e','\\u000b}\\u000b\\u000b\\u0003\\u000b\\u0005\\u000b€\\n\\u000b\\u0003\\f\\u0003','\\f\\u0003\\f\\u0003\\f\\u0003\\f\\u0003\\f\\u0003\\f\\u0003\\r\\u0003\\r\\u0003\\r\\u0003','\\u000e\\u0003\\u000e\\u0003\\u000e\\u0003\\u000e\\u0003\\u000e\\u0003\\u000e\\u0003','\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003','\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0005\\u000fœ\\n\\u000f','\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f','\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f','\\u0003\\u000f\\u0003\\u000f\\u0006\\u000f¬\\n\\u000f\\r\\u000f\\u000e\\u000f','­\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003','\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003','\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003','\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003\\u000f\\u0003','\\u000f\\u0003\\u000f\\u0007\\u000fÉ\\n\\u000f\\f\\u000f\\u000e\\u000fÌ','\\u000b\\u000f\\u0003\\u0010\\u0003\\u0010\\u0003\\u0010\\u0005\\u0010Ñ\\n','\\u0010\\u0003\\u0011\\u0003\\u0011\\u0007\\u0011Õ\\n\\u0011\\f\\u0011\\u000e','\\u0011Ø\\u000b\\u0011\\u0003\\u0011\\u0003\\u0011\\u0003\\u0012\\u0003\\u0012','\\u0003\\u0012\\u0003\\u0012\\u0003\\u0012\\u0005\\u0012á\\n\\u0012\\u0003','\\u0013\\u0003\\u0013\\u0003\\u0013\\u0005\\u0013æ\\n\\u0013\\u0003\\u0014','\\u0003\\u0014\\u0005\\u0014ê\\n\\u0014\\u0003\\u0015\\u0003\\u0015\\u0003','\\u0015\\u0003\\u0015\\u0007\\u0015ð\\n\\u0015\\f\\u0015\\u000e\\u0015ó','\\u000b\\u0015\\u0003\\u0015\\u0003\\u0015\\u0003\\u0015\\u0003\\u0015\\u0005\\u0015','ù\\n\\u0015\\u0003\\u0016\\u0003\\u0016\\u0003\\u0016\\u0003\\u0016\\u0003','\\u0017\\u0003\\u0017\\u0003\\u0017\\u0003\\u0017\\u0007\\u0017ă\\n\\u0017','\\f\\u0017\\u000e\\u0017Ć\\u000b\\u0017\\u0003\\u0017\\u0003\\u0017\\u0003','\\u0017\\u0003\\u0017\\u0005\\u0017Č\\n\\u0017\\u0003\\u0018\\u0003\\u0018','\\u0003\\u0018\\u0003\\u0018\\u0003\\u0018\\u0003\\u0018\\u0003\\u0018\\u0005\\u0018','ĕ\\n\\u0018\\u0003\\u0018\\u0002\\u0003\\u001c\\u0019\\u0002\\u0004\\u0006','\\b\\n\\f\\u000e\\u0010\\u0012\\u0014\\u0016\\u0018\\u001a\\u001c\\u001e \"$&(*',',.\\u0002\\u0003\\u0003\\u0002\\u001b\\u001cī\\u00020\\u0003\\u0002\\u0002','\\u0002\\u00047\\u0003\\u0002\\u0002\\u0002\\u0006;\\u0003\\u0002\\u0002\\u0002','\\b?\\u0003\\u0002\\u0002\\u0002\\nO\\u0003\\u0002\\u0002\\u0002\\f]\\u0003\\u0002','\\u0002\\u0002\\u000ed\\u0003\\u0002\\u0002\\u0002\\u0010l\\u0003\\u0002\\u0002','\\u0002\\u0012p\\u0003\\u0002\\u0002\\u0002\\u0014s\\u0003\\u0002\\u0002\\u0002','\\u0016\\u0003\\u0002\\u0002\\u0002\\u0018ˆ\\u0003\\u0002\\u0002\\u0002','\\u001a‹\\u0003\\u0002\\u0002\\u0002\\u001c›\\u0003\\u0002\\u0002\\u0002','\\u001eÐ\\u0003\\u0002\\u0002\\u0002 Ò\\u0003\\u0002\\u0002\\u0002','\"à\\u0003\\u0002\\u0002\\u0002$å\\u0003\\u0002\\u0002\\u0002&é','\\u0003\\u0002\\u0002\\u0002(ø\\u0003\\u0002\\u0002\\u0002*ú\\u0003','\\u0002\\u0002\\u0002,ċ\\u0003\\u0002\\u0002\\u0002.Ĕ\\u0003\\u0002','\\u0002\\u000204\\u0005\\u0004\\u0003\\u000213\\u0005\\b\\u0005\\u000221\\u0003','\\u0002\\u0002\\u000236\\u0003\\u0002\\u0002\\u000242\\u0003\\u0002\\u0002\\u0002','45\\u0003\\u0002\\u0002\\u00025\\u0003\\u0003\\u0002\\u0002\\u000264\\u0003\\u0002','\\u0002\\u000278\\u0007\\u0003\\u0002\\u000289\\u0005\\u000e\\b\\u00029:\\u0007','\\u0004\\u0002\\u0002:\\u0005\\u0003\\u0002\\u0002\\u0002;<\\u0005\\f\\u0007\\u0002','<=\\u0007\\u0005\\u0002\\u0002=>\\u0005\\u001c\\u000f\\u0002>\\u0007\\u0003\\u0002','\\u0002\\u0002?@\\u0007\\u0006\\u0002\\u0002@A\\u0007&\\u0002\\u0002AC\\u0007','\\u0007\\u0002\\u0002BD\\u0007&\\u0002\\u0002CB\\u0003\\u0002\\u0002\\u0002CD','\\u0003\\u0002\\u0002\\u0002DI\\u0003\\u0002\\u0002\\u0002EF\\u0007\\b\\u0002\\u0002','FH\\u0007&\\u0002\\u0002GE\\u0003\\u0002\\u0002\\u0002HK\\u0003\\u0002\\u0002','\\u0002IG\\u0003\\u0002\\u0002\\u0002IJ\\u0003\\u0002\\u0002\\u0002JL\\u0003\\u0002','\\u0002\\u0002KI\\u0003\\u0002\\u0002\\u0002LM\\u0007\\t\\u0002\\u0002MN\\u0005',' \\u0011\\u0002N\\t\\u0003\\u0002\\u0002\\u0002OP\\u0005\\u000e\\b\\u0002PR\\u0007','\\u0007\\u0002\\u0002QS\\u0005\\u001e\\u0010\\u0002RQ\\u0003\\u0002\\u0002\\u0002','RS\\u0003\\u0002\\u0002\\u0002SX\\u0003\\u0002\\u0002\\u0002TU\\u0007\\b\\u0002','\\u0002UW\\u0005\\u001e\\u0010\\u0002VT\\u0003\\u0002\\u0002\\u0002WZ\\u0003\\u0002','\\u0002\\u0002XV\\u0003\\u0002\\u0002\\u0002XY\\u0003\\u0002\\u0002\\u0002Y[\\u0003','\\u0002\\u0002\\u0002ZX\\u0003\\u0002\\u0002\\u0002[\\\\\\u0007\\t\\u0002\\u0002','\\\\\\u000b\\u0003\\u0002\\u0002\\u0002]a\\u0007&\\u0002\\u0002^`\\u0005\\u0010','\\t\\u0002_^\\u0003\\u0002\\u0002\\u0002`c\\u0003\\u0002\\u0002\\u0002a_\\u0003','\\u0002\\u0002\\u0002ab\\u0003\\u0002\\u0002\\u0002b\\r\\u0003\\u0002\\u0002\\u0002','ca\\u0003\\u0002\\u0002\\u0002di\\u0007&\\u0002\\u0002ef\\u0007\\n\\u0002\\u0002','fh\\u0007&\\u0002\\u0002ge\\u0003\\u0002\\u0002\\u0002hk\\u0003\\u0002\\u0002','\\u0002ig\\u0003\\u0002\\u0002\\u0002ij\\u0003\\u0002\\u0002\\u0002j\\u000f\\u0003','\\u0002\\u0002\\u0002ki\\u0003\\u0002\\u0002\\u0002lm\\u0007\\u000b\\u0002\\u0002','mn\\u0005\\u001e\\u0010\\u0002no\\u0007\\f\\u0002\\u0002o\\u0011\\u0003\\u0002','\\u0002\\u0002pq\\u0007\\r\\u0002\\u0002qr\\u0005\\u001c\\u000f\\u0002r\\u0013','\\u0003\\u0002\\u0002\\u0002st\\u0007\\u000e\\u0002\\u0002tu\\u0007\\u0007\\u0002','\\u0002uv\\u0005\\u001c\\u000f\\u0002vw\\u0007\\t\\u0002\\u0002w{\\u0005 \\u0011','\\u0002xz\\u0005\\u0016\\f\\u0002yx\\u0003\\u0002\\u0002\\u0002z}\\u0003\\u0002','\\u0002\\u0002{y\\u0003\\u0002\\u0002\\u0002{|\\u0003\\u0002\\u0002\\u0002|','\\u0003\\u0002\\u0002\\u0002}{\\u0003\\u0002\\u0002\\u0002~€\\u0005\\u0018','\\r\\u0002~\\u0003\\u0002\\u0002\\u0002€\\u0003\\u0002\\u0002','\\u0002€\\u0015\\u0003\\u0002\\u0002\\u0002‚\\u0007\\u000f\\u0002','\\u0002‚ƒ\\u0007\\u000e\\u0002\\u0002ƒ„\\u0007\\u0007\\u0002','\\u0002„…\\u0005\\u001c\\u000f\\u0002…†\\u0007\\t\\u0002','\\u0002†‡\\u0005 \\u0011\\u0002‡\\u0017\\u0003\\u0002\\u0002','\\u0002ˆ‰\\u0007\\u000f\\u0002\\u0002‰Š\\u0005 \\u0011','\\u0002Š\\u0019\\u0003\\u0002\\u0002\\u0002‹Œ\\u0007\\u0010\\u0002','\\u0002Œ\\u0007\\u0007\\u0002\\u0002Ž\\u0005\\u001c\\u000f','\\u0002Ž\\u0007\\t\\u0002\\u0002\\u0005 \\u0011\\u0002','\\u001b\\u0003\\u0002\\u0002\\u0002‘’\\b\\u000f\\u0001\\u0002','’“\\u0007\\u0007\\u0002\\u0002“”\\u0005\\u001c\\u000f\\u0002','”•\\u0007\\t\\u0002\\u0002•œ\\u0003\\u0002\\u0002\\u0002','–—\\u0007\\u001c\\u0002\\u0002—œ\\u0005\\u001c\\u000f\\r','˜™\\u0007\\u001d\\u0002\\u0002™œ\\u0005\\u001c\\u000f\\f','šœ\\u0005\\u001e\\u0010\\u0002›‘\\u0003\\u0002\\u0002\\u0002','›–\\u0003\\u0002\\u0002\\u0002›˜\\u0003\\u0002\\u0002\\u0002','›š\\u0003\\u0002\\u0002\\u0002œÊ\\u0003\\u0002\\u0002\\u0002','ž\\f\\u0012\\u0002\\u0002žŸ\\u0007\\u0017\\u0002\\u0002','ŸÉ\\u0005\\u001c\\u000f\\u0012 ¡\\f\\u0011\\u0002\\u0002','¡¢\\u0007\\u0018\\u0002\\u0002¢É\\u0005\\u001c\\u000f\\u0012','£¤\\f\\u0010\\u0002\\u0002¤¥\\u0007\\u0019\\u0002\\u0002','¥É\\u0005\\u001c\\u000f\\u0011¦§\\f\\u000f\\u0002\\u0002','§¨\\u0007\\u001a\\u0002\\u0002¨É\\u0005\\u001c\\u000f\\u0010','©«\\f\\u000e\\u0002\\u0002ª¬\\t\\u0002\\u0002\\u0002«','ª\\u0003\\u0002\\u0002\\u0002¬­\\u0003\\u0002\\u0002\\u0002­','«\\u0003\\u0002\\u0002\\u0002­®\\u0003\\u0002\\u0002\\u0002®','¯\\u0003\\u0002\\u0002\\u0002¯É\\u0005\\u001c\\u000f\\u000f°','±\\f\\u000b\\u0002\\u0002±²\\u0007\\u001e\\u0002\\u0002²','É\\u0005\\u001c\\u000f\\f³´\\f\\n\\u0002\\u0002´µ\\u0007','\\u001f\\u0002\\u0002µÉ\\u0005\\u001c\\u000f\\u000b¶·\\f','\\t\\u0002\\u0002·¸\\u0007 \\u0002\\u0002¸É\\u0005\\u001c','\\u000f\\n¹º\\f\\b\\u0002\\u0002º»\\u0007!\\u0002\\u0002','»É\\u0005\\u001c\\u000f\\t¼½\\f\\u0007\\u0002\\u0002½','¾\\u0007\"\\u0002\\u0002¾É\\u0005\\u001c\\u000f\\b¿À','\\f\\u0006\\u0002\\u0002ÀÁ\\u0007#\\u0002\\u0002ÁÉ\\u0005','\\u001c\\u000f\\u0007ÂÃ\\f\\u0005\\u0002\\u0002ÃÄ\\u0007','$\\u0002\\u0002ÄÉ\\u0005\\u001c\\u000f\\u0006ÅÆ\\f\\u0004','\\u0002\\u0002ÆÇ\\u0007%\\u0002\\u0002ÇÉ\\u0005\\u001c','\\u000f\\u0005ȝ\\u0003\\u0002\\u0002\\u0002È \\u0003\\u0002','\\u0002\\u0002È£\\u0003\\u0002\\u0002\\u0002Ȧ\\u0003\\u0002','\\u0002\\u0002È©\\u0003\\u0002\\u0002\\u0002È°\\u0003\\u0002','\\u0002\\u0002ȳ\\u0003\\u0002\\u0002\\u0002ȶ\\u0003\\u0002','\\u0002\\u0002ȹ\\u0003\\u0002\\u0002\\u0002ȼ\\u0003\\u0002','\\u0002\\u0002È¿\\u0003\\u0002\\u0002\\u0002ÈÂ\\u0003\\u0002','\\u0002\\u0002ÈÅ\\u0003\\u0002\\u0002\\u0002ÉÌ\\u0003\\u0002','\\u0002\\u0002ÊÈ\\u0003\\u0002\\u0002\\u0002ÊË\\u0003\\u0002','\\u0002\\u0002Ë\\u001d\\u0003\\u0002\\u0002\\u0002ÌÊ\\u0003\\u0002','\\u0002\\u0002ÍÑ\\u0005.\\u0018\\u0002ÎÑ\\u0005\\f\\u0007','\\u0002ÏÑ\\u0005\\n\\u0006\\u0002ÐÍ\\u0003\\u0002\\u0002','\\u0002ÐÎ\\u0003\\u0002\\u0002\\u0002ÐÏ\\u0003\\u0002\\u0002','\\u0002Ñ\\u001f\\u0003\\u0002\\u0002\\u0002ÒÖ\\u0007\\u0011\\u0002','\\u0002ÓÕ\\u0005\"\\u0012\\u0002ÔÓ\\u0003\\u0002\\u0002','\\u0002ÕØ\\u0003\\u0002\\u0002\\u0002ÖÔ\\u0003\\u0002\\u0002','\\u0002Ö×\\u0003\\u0002\\u0002\\u0002×Ù\\u0003\\u0002\\u0002','\\u0002ØÖ\\u0003\\u0002\\u0002\\u0002ÙÚ\\u0007\\u0012\\u0002','\\u0002Ú!\\u0003\\u0002\\u0002\\u0002ÛÜ\\u0005$\\u0013\\u0002','ÜÝ\\u0007\\u0004\\u0002\\u0002Ýá\\u0003\\u0002\\u0002\\u0002','Þá\\u0005\\u001a\\u000e\\u0002ßá\\u0005\\u0014\\u000b\\u0002','àÛ\\u0003\\u0002\\u0002\\u0002àÞ\\u0003\\u0002\\u0002\\u0002','àß\\u0003\\u0002\\u0002\\u0002á#\\u0003\\u0002\\u0002\\u0002','âæ\\u0005\\u0006\\u0004\\u0002ãæ\\u0005\\n\\u0006\\u0002','äæ\\u0005\\u0012\\n\\u0002åâ\\u0003\\u0002\\u0002\\u0002','åã\\u0003\\u0002\\u0002\\u0002åä\\u0003\\u0002\\u0002\\u0002','æ%\\u0003\\u0002\\u0002\\u0002çê\\u0005(\\u0015\\u0002è','ê\\u0005,\\u0017\\u0002éç\\u0003\\u0002\\u0002\\u0002é','è\\u0003\\u0002\\u0002\\u0002ê\\'\\u0003\\u0002\\u0002\\u0002ë','ì\\u0007\\u0011\\u0002\\u0002ìñ\\u0005*\\u0016\\u0002í','î\\u0007\\b\\u0002\\u0002îð\\u0005*\\u0016\\u0002ïí','\\u0003\\u0002\\u0002\\u0002ðó\\u0003\\u0002\\u0002\\u0002ñï','\\u0003\\u0002\\u0002\\u0002ñò\\u0003\\u0002\\u0002\\u0002òô','\\u0003\\u0002\\u0002\\u0002óñ\\u0003\\u0002\\u0002\\u0002ôõ','\\u0007\\u0012\\u0002\\u0002õù\\u0003\\u0002\\u0002\\u0002ö÷','\\u0007\\u0011\\u0002\\u0002÷ù\\u0007\\u0012\\u0002\\u0002øë','\\u0003\\u0002\\u0002\\u0002øö\\u0003\\u0002\\u0002\\u0002ù)','\\u0003\\u0002\\u0002\\u0002úû\\u0007)\\u0002\\u0002ûü','\\u0007\\u0013\\u0002\\u0002üý\\u0005.\\u0018\\u0002ý+\\u0003','\\u0002\\u0002\\u0002þÿ\\u0007\\u000b\\u0002\\u0002ÿĄ\\u0005','.\\u0018\\u0002Āā\\u0007\\b\\u0002\\u0002āă\\u0005.\\u0018','\\u0002ĂĀ\\u0003\\u0002\\u0002\\u0002ăĆ\\u0003\\u0002\\u0002','\\u0002ĄĂ\\u0003\\u0002\\u0002\\u0002Ąą\\u0003\\u0002\\u0002','\\u0002ąć\\u0003\\u0002\\u0002\\u0002ĆĄ\\u0003\\u0002\\u0002','\\u0002ćĈ\\u0007\\f\\u0002\\u0002ĈČ\\u0003\\u0002\\u0002','\\u0002ĉĊ\\u0007\\u000b\\u0002\\u0002ĊČ\\u0007\\f\\u0002','\\u0002ċþ\\u0003\\u0002\\u0002\\u0002ċĉ\\u0003\\u0002\\u0002','\\u0002Č-\\u0003\\u0002\\u0002\\u0002čĕ\\u0007)\\u0002\\u0002','Ďĕ\\u0007*\\u0002\\u0002ďĕ\\u0005(\\u0015\\u0002Đ','ĕ\\u0005,\\u0017\\u0002đĕ\\u0007\\u0014\\u0002\\u0002Ē','ĕ\\u0007\\u0015\\u0002\\u0002ēĕ\\u0007\\u0016\\u0002\\u0002Ĕ','č\\u0003\\u0002\\u0002\\u0002ĔĎ\\u0003\\u0002\\u0002\\u0002Ĕ','ď\\u0003\\u0002\\u0002\\u0002ĔĐ\\u0003\\u0002\\u0002\\u0002Ĕ','đ\\u0003\\u0002\\u0002\\u0002ĔĒ\\u0003\\u0002\\u0002\\u0002Ĕ','ē\\u0003\\u0002\\u0002\\u0002ĕ/\\u0003\\u0002\\u0002\\u0002\\u0019','4CIRXai{›­ÈÊÐÖàåé','ñøĄċĔ'].join(\"\");var atn=new antlr4.atn.ATNDeserializer().deserialize(serializedATN);var decisionsToDFA=atn.decisionToState.map(function(ds,index){return new antlr4.dfa.DFA(ds,index);});var sharedContextCache=new antlr4.PredictionContextCache();var literalNames=[null,\"'pack'\",\"';'\",\"'='\",\"'func'\",\"'('\",\"','\",\"')'\",\"'.'\",\"'['\",\"']'\",\"'ret'\",\"'if'\",\"'else'\",\"'while'\",\"'{'\",\"'}'\",\"':'\",\"'true'\",\"'false'\",\"'null'\",\"'^'\",\"'*'\",\"'/'\",\"'%'\",\"'+'\",\"'-'\",\"'!'\",\"'=='\",\"'!='\",\"'<'\",\"'<='\",\"'>'\",\"'>='\",\"'&&'\",\"'||'\"];var symbolicNames=[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,\"Pow\",\"Mul\",\"Div\",\"Mod\",\"Plus\",\"Minus\",\"Not\",\"Eq\",\"Neq\",\"Lt\",\"Le\",\"Gt\",\"Ge\",\"And\",\"Or\",\"Id\",\"Comment\",\"WS\",\"STRING\",\"NUMBER\"];var ruleNames=[\"smkFile\",\"packageDecl\",\"varAssign\",\"funcDecl\",\"funcInvoke\",\"jsonPath\",\"dottedId\",\"keyRef\",\"retStatement\",\"ifStat\",\"elseIfStat\",\"elseStat\",\"loop\",\"expression\",\"resolvable\",\"codeBlock\",\"sentence\",\"statement\",\"json\",\"object\",\"pair\",\"array\",\"value\"];function SmackParser(input){antlr4.Parser.call(this,input);this._interp = new antlr4.atn.ParserATNSimulator(this,atn,decisionsToDFA,sharedContextCache);this.ruleNames = ruleNames;this.literalNames = literalNames;this.symbolicNames = symbolicNames;return this;}SmackParser.prototype = Object.create(antlr4.Parser.prototype);SmackParser.prototype.constructor = SmackParser;Object.defineProperty(SmackParser.prototype,\"atn\",{get:function get(){return atn;}});SmackParser.EOF = antlr4.Token.EOF;SmackParser.T__0 = 1;SmackParser.T__1 = 2;SmackParser.T__2 = 3;SmackParser.T__3 = 4;SmackParser.T__4 = 5;SmackParser.T__5 = 6;SmackParser.T__6 = 7;SmackParser.T__7 = 8;SmackParser.T__8 = 9;SmackParser.T__9 = 10;SmackParser.T__10 = 11;SmackParser.T__11 = 12;SmackParser.T__12 = 13;SmackParser.T__13 = 14;SmackParser.T__14 = 15;SmackParser.T__15 = 16;SmackParser.T__16 = 17;SmackParser.T__17 = 18;SmackParser.T__18 = 19;SmackParser.T__19 = 20;SmackParser.Pow = 21;SmackParser.Mul = 22;SmackParser.Div = 23;SmackParser.Mod = 24;SmackParser.Plus = 25;SmackParser.Minus = 26;SmackParser.Not = 27;SmackParser.Eq = 28;SmackParser.Neq = 29;SmackParser.Lt = 30;SmackParser.Le = 31;SmackParser.Gt = 32;SmackParser.Ge = 33;SmackParser.And = 34;SmackParser.Or = 35;SmackParser.Id = 36;SmackParser.Comment = 37;SmackParser.WS = 38;SmackParser.STRING = 39;SmackParser.NUMBER = 40;SmackParser.RULE_smkFile = 0;SmackParser.RULE_packageDecl = 1;SmackParser.RULE_varAssign = 2;SmackParser.RULE_funcDecl = 3;SmackParser.RULE_funcInvoke = 4;SmackParser.RULE_jsonPath = 5;SmackParser.RULE_dottedId = 6;SmackParser.RULE_keyRef = 7;SmackParser.RULE_retStatement = 8;SmackParser.RULE_ifStat = 9;SmackParser.RULE_elseIfStat = 10;SmackParser.RULE_elseStat = 11;SmackParser.RULE_loop = 12;SmackParser.RULE_expression = 13;SmackParser.RULE_resolvable = 14;SmackParser.RULE_codeBlock = 15;SmackParser.RULE_sentence = 16;SmackParser.RULE_statement = 17;SmackParser.RULE_json = 18;SmackParser.RULE_object = 19;SmackParser.RULE_pair = 20;SmackParser.RULE_array = 21;SmackParser.RULE_value = 22;function SmkFileContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_smkFile;return this;}SmkFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);SmkFileContext.prototype.constructor = SmkFileContext;SmkFileContext.prototype.packageDecl = function(){return this.getTypedRuleContext(PackageDeclContext,0);};SmkFileContext.prototype.funcDecl = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(FuncDeclContext);}else {return this.getTypedRuleContext(FuncDeclContext,i);}};SmkFileContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterSmkFile(this);}};SmkFileContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitSmkFile(this);}};SmkFileContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitSmkFile(this);}else {return visitor.visitChildren(this);}};SmackParser.SmkFileContext = SmkFileContext;SmackParser.prototype.smkFile = function(){var localctx=new SmkFileContext(this,this._ctx,this.state);this.enterRule(localctx,0,SmackParser.RULE_smkFile);var _la=0; // Token type\ntry{this.enterOuterAlt(localctx,1);this.state = 46;this.packageDecl();this.state = 50;this._errHandler.sync(this);_la = this._input.LA(1);while(_la === SmackParser.T__3) {this.state = 47;this.funcDecl();this.state = 52;this._errHandler.sync(this);_la = this._input.LA(1);}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function PackageDeclContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_packageDecl;return this;}PackageDeclContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);PackageDeclContext.prototype.constructor = PackageDeclContext;PackageDeclContext.prototype.dottedId = function(){return this.getTypedRuleContext(DottedIdContext,0);};PackageDeclContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterPackageDecl(this);}};PackageDeclContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitPackageDecl(this);}};PackageDeclContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitPackageDecl(this);}else {return visitor.visitChildren(this);}};SmackParser.PackageDeclContext = PackageDeclContext;SmackParser.prototype.packageDecl = function(){var localctx=new PackageDeclContext(this,this._ctx,this.state);this.enterRule(localctx,2,SmackParser.RULE_packageDecl);try{this.enterOuterAlt(localctx,1);this.state = 53;this.match(SmackParser.T__0);this.state = 54;this.dottedId();this.state = 55;this.match(SmackParser.T__1);}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function VarAssignContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_varAssign;return this;}VarAssignContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);VarAssignContext.prototype.constructor = VarAssignContext;VarAssignContext.prototype.jsonPath = function(){return this.getTypedRuleContext(JsonPathContext,0);};VarAssignContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};VarAssignContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterVarAssign(this);}};VarAssignContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitVarAssign(this);}};VarAssignContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitVarAssign(this);}else {return visitor.visitChildren(this);}};SmackParser.VarAssignContext = VarAssignContext;SmackParser.prototype.varAssign = function(){var localctx=new VarAssignContext(this,this._ctx,this.state);this.enterRule(localctx,4,SmackParser.RULE_varAssign);try{this.enterOuterAlt(localctx,1);this.state = 57;this.jsonPath();this.state = 58;this.match(SmackParser.T__2);this.state = 59;this.expression(0);}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function FuncDeclContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_funcDecl;return this;}FuncDeclContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);FuncDeclContext.prototype.constructor = FuncDeclContext;FuncDeclContext.prototype.Id = function(i){if(i === undefined){i = null;}if(i === null){return this.getTokens(SmackParser.Id);}else {return this.getToken(SmackParser.Id,i);}};FuncDeclContext.prototype.codeBlock = function(){return this.getTypedRuleContext(CodeBlockContext,0);};FuncDeclContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterFuncDecl(this);}};FuncDeclContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitFuncDecl(this);}};FuncDeclContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitFuncDecl(this);}else {return visitor.visitChildren(this);}};SmackParser.FuncDeclContext = FuncDeclContext;SmackParser.prototype.funcDecl = function(){var localctx=new FuncDeclContext(this,this._ctx,this.state);this.enterRule(localctx,6,SmackParser.RULE_funcDecl);var _la=0; // Token type\ntry{this.enterOuterAlt(localctx,1);this.state = 61;this.match(SmackParser.T__3);this.state = 62;this.match(SmackParser.Id);this.state = 63;this.match(SmackParser.T__4);this.state = 65;_la = this._input.LA(1);if(_la === SmackParser.Id){this.state = 64;this.match(SmackParser.Id);}this.state = 71;this._errHandler.sync(this);_la = this._input.LA(1);while(_la === SmackParser.T__5) {this.state = 67;this.match(SmackParser.T__5);this.state = 68;this.match(SmackParser.Id);this.state = 73;this._errHandler.sync(this);_la = this._input.LA(1);}this.state = 74;this.match(SmackParser.T__6);this.state = 75;this.codeBlock();}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function FuncInvokeContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_funcInvoke;return this;}FuncInvokeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);FuncInvokeContext.prototype.constructor = FuncInvokeContext;FuncInvokeContext.prototype.dottedId = function(){return this.getTypedRuleContext(DottedIdContext,0);};FuncInvokeContext.prototype.resolvable = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ResolvableContext);}else {return this.getTypedRuleContext(ResolvableContext,i);}};FuncInvokeContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterFuncInvoke(this);}};FuncInvokeContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitFuncInvoke(this);}};FuncInvokeContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitFuncInvoke(this);}else {return visitor.visitChildren(this);}};SmackParser.FuncInvokeContext = FuncInvokeContext;SmackParser.prototype.funcInvoke = function(){var localctx=new FuncInvokeContext(this,this._ctx,this.state);this.enterRule(localctx,8,SmackParser.RULE_funcInvoke);var _la=0; // Token type\ntry{this.enterOuterAlt(localctx,1);this.state = 77;this.dottedId();this.state = 78;this.match(SmackParser.T__4);this.state = 80;_la = this._input.LA(1);if((_la - 9 & ~0x1f) == 0 && (1 << _la - 9 & (1 << SmackParser.T__8 - 9 | 1 << SmackParser.T__14 - 9 | 1 << SmackParser.T__17 - 9 | 1 << SmackParser.T__18 - 9 | 1 << SmackParser.T__19 - 9 | 1 << SmackParser.Id - 9 | 1 << SmackParser.STRING - 9 | 1 << SmackParser.NUMBER - 9)) !== 0){this.state = 79;this.resolvable();}this.state = 86;this._errHandler.sync(this);_la = this._input.LA(1);while(_la === SmackParser.T__5) {this.state = 82;this.match(SmackParser.T__5);this.state = 83;this.resolvable();this.state = 88;this._errHandler.sync(this);_la = this._input.LA(1);}this.state = 89;this.match(SmackParser.T__6);}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function JsonPathContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_jsonPath;return this;}JsonPathContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);JsonPathContext.prototype.constructor = JsonPathContext;JsonPathContext.prototype.Id = function(){return this.getToken(SmackParser.Id,0);};JsonPathContext.prototype.keyRef = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(KeyRefContext);}else {return this.getTypedRuleContext(KeyRefContext,i);}};JsonPathContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterJsonPath(this);}};JsonPathContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitJsonPath(this);}};JsonPathContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitJsonPath(this);}else {return visitor.visitChildren(this);}};SmackParser.JsonPathContext = JsonPathContext;SmackParser.prototype.jsonPath = function(){var localctx=new JsonPathContext(this,this._ctx,this.state);this.enterRule(localctx,10,SmackParser.RULE_jsonPath);try{this.enterOuterAlt(localctx,1);this.state = 91;this.match(SmackParser.Id);this.state = 95;this._errHandler.sync(this);var _alt=this._interp.adaptivePredict(this._input,5,this._ctx);while(_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {if(_alt === 1){this.state = 92;this.keyRef();}this.state = 97;this._errHandler.sync(this);_alt = this._interp.adaptivePredict(this._input,5,this._ctx);}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function DottedIdContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_dottedId;return this;}DottedIdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);DottedIdContext.prototype.constructor = DottedIdContext;DottedIdContext.prototype.Id = function(i){if(i === undefined){i = null;}if(i === null){return this.getTokens(SmackParser.Id);}else {return this.getToken(SmackParser.Id,i);}};DottedIdContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterDottedId(this);}};DottedIdContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitDottedId(this);}};DottedIdContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitDottedId(this);}else {return visitor.visitChildren(this);}};SmackParser.DottedIdContext = DottedIdContext;SmackParser.prototype.dottedId = function(){var localctx=new DottedIdContext(this,this._ctx,this.state);this.enterRule(localctx,12,SmackParser.RULE_dottedId);var _la=0; // Token type\ntry{this.enterOuterAlt(localctx,1);this.state = 98;this.match(SmackParser.Id);this.state = 103;this._errHandler.sync(this);_la = this._input.LA(1);while(_la === SmackParser.T__7) {this.state = 99;this.match(SmackParser.T__7);this.state = 100;this.match(SmackParser.Id);this.state = 105;this._errHandler.sync(this);_la = this._input.LA(1);}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function KeyRefContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_keyRef;return this;}KeyRefContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);KeyRefContext.prototype.constructor = KeyRefContext;KeyRefContext.prototype.resolvable = function(){return this.getTypedRuleContext(ResolvableContext,0);};KeyRefContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterKeyRef(this);}};KeyRefContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitKeyRef(this);}};KeyRefContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitKeyRef(this);}else {return visitor.visitChildren(this);}};SmackParser.KeyRefContext = KeyRefContext;SmackParser.prototype.keyRef = function(){var localctx=new KeyRefContext(this,this._ctx,this.state);this.enterRule(localctx,14,SmackParser.RULE_keyRef);try{this.enterOuterAlt(localctx,1);this.state = 106;this.match(SmackParser.T__8);this.state = 107;this.resolvable();this.state = 108;this.match(SmackParser.T__9);}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function RetStatementContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_retStatement;return this;}RetStatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);RetStatementContext.prototype.constructor = RetStatementContext;RetStatementContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};RetStatementContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterRetStatement(this);}};RetStatementContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitRetStatement(this);}};RetStatementContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitRetStatement(this);}else {return visitor.visitChildren(this);}};SmackParser.RetStatementContext = RetStatementContext;SmackParser.prototype.retStatement = function(){var localctx=new RetStatementContext(this,this._ctx,this.state);this.enterRule(localctx,16,SmackParser.RULE_retStatement);try{this.enterOuterAlt(localctx,1);this.state = 110;this.match(SmackParser.T__10);this.state = 111;this.expression(0);}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function IfStatContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_ifStat;return this;}IfStatContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);IfStatContext.prototype.constructor = IfStatContext;IfStatContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};IfStatContext.prototype.codeBlock = function(){return this.getTypedRuleContext(CodeBlockContext,0);};IfStatContext.prototype.elseIfStat = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ElseIfStatContext);}else {return this.getTypedRuleContext(ElseIfStatContext,i);}};IfStatContext.prototype.elseStat = function(){return this.getTypedRuleContext(ElseStatContext,0);};IfStatContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterIfStat(this);}};IfStatContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitIfStat(this);}};IfStatContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitIfStat(this);}else {return visitor.visitChildren(this);}};SmackParser.IfStatContext = IfStatContext;SmackParser.prototype.ifStat = function(){var localctx=new IfStatContext(this,this._ctx,this.state);this.enterRule(localctx,18,SmackParser.RULE_ifStat);var _la=0; // Token type\ntry{this.enterOuterAlt(localctx,1);this.state = 113;this.match(SmackParser.T__11);this.state = 114;this.match(SmackParser.T__4);this.state = 115;this.expression(0);this.state = 116;this.match(SmackParser.T__6);this.state = 117;this.codeBlock();this.state = 121;this._errHandler.sync(this);var _alt=this._interp.adaptivePredict(this._input,7,this._ctx);while(_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {if(_alt === 1){this.state = 118;this.elseIfStat();}this.state = 123;this._errHandler.sync(this);_alt = this._interp.adaptivePredict(this._input,7,this._ctx);}this.state = 125;_la = this._input.LA(1);if(_la === SmackParser.T__12){this.state = 124;this.elseStat();}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function ElseIfStatContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_elseIfStat;return this;}ElseIfStatContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);ElseIfStatContext.prototype.constructor = ElseIfStatContext;ElseIfStatContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};ElseIfStatContext.prototype.codeBlock = function(){return this.getTypedRuleContext(CodeBlockContext,0);};ElseIfStatContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterElseIfStat(this);}};ElseIfStatContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitElseIfStat(this);}};ElseIfStatContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitElseIfStat(this);}else {return visitor.visitChildren(this);}};SmackParser.ElseIfStatContext = ElseIfStatContext;SmackParser.prototype.elseIfStat = function(){var localctx=new ElseIfStatContext(this,this._ctx,this.state);this.enterRule(localctx,20,SmackParser.RULE_elseIfStat);try{this.enterOuterAlt(localctx,1);this.state = 127;this.match(SmackParser.T__12);this.state = 128;this.match(SmackParser.T__11);this.state = 129;this.match(SmackParser.T__4);this.state = 130;this.expression(0);this.state = 131;this.match(SmackParser.T__6);this.state = 132;this.codeBlock();}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function ElseStatContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_elseStat;return this;}ElseStatContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);ElseStatContext.prototype.constructor = ElseStatContext;ElseStatContext.prototype.codeBlock = function(){return this.getTypedRuleContext(CodeBlockContext,0);};ElseStatContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterElseStat(this);}};ElseStatContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitElseStat(this);}};ElseStatContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitElseStat(this);}else {return visitor.visitChildren(this);}};SmackParser.ElseStatContext = ElseStatContext;SmackParser.prototype.elseStat = function(){var localctx=new ElseStatContext(this,this._ctx,this.state);this.enterRule(localctx,22,SmackParser.RULE_elseStat);try{this.enterOuterAlt(localctx,1);this.state = 134;this.match(SmackParser.T__12);this.state = 135;this.codeBlock();}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function LoopContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_loop;return this;}LoopContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);LoopContext.prototype.constructor = LoopContext;LoopContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};LoopContext.prototype.codeBlock = function(){return this.getTypedRuleContext(CodeBlockContext,0);};LoopContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterLoop(this);}};LoopContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitLoop(this);}};LoopContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitLoop(this);}else {return visitor.visitChildren(this);}};SmackParser.LoopContext = LoopContext;SmackParser.prototype.loop = function(){var localctx=new LoopContext(this,this._ctx,this.state);this.enterRule(localctx,24,SmackParser.RULE_loop);try{this.enterOuterAlt(localctx,1);this.state = 137;this.match(SmackParser.T__13);this.state = 138;this.match(SmackParser.T__4);this.state = 139;this.expression(0);this.state = 140;this.match(SmackParser.T__6);this.state = 141;this.codeBlock();}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function ExpressionContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_expression;return this;}ExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);ExpressionContext.prototype.constructor = ExpressionContext;ExpressionContext.prototype.copyFrom = function(ctx){antlr4.ParserRuleContext.prototype.copyFrom.call(this,ctx);};function SignedExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}SignedExprContext.prototype = Object.create(ExpressionContext.prototype);SignedExprContext.prototype.constructor = SignedExprContext;SmackParser.SignedExprContext = SignedExprContext;SignedExprContext.prototype.Minus = function(){return this.getToken(SmackParser.Minus,0);};SignedExprContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};SignedExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterSignedExpr(this);}};SignedExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitSignedExpr(this);}};SignedExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitSignedExpr(this);}else {return visitor.visitChildren(this);}};function GeExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}GeExprContext.prototype = Object.create(ExpressionContext.prototype);GeExprContext.prototype.constructor = GeExprContext;SmackParser.GeExprContext = GeExprContext;GeExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};GeExprContext.prototype.Ge = function(){return this.getToken(SmackParser.Ge,0);};GeExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterGeExpr(this);}};GeExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitGeExpr(this);}};GeExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitGeExpr(this);}else {return visitor.visitChildren(this);}};function ModExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}ModExprContext.prototype = Object.create(ExpressionContext.prototype);ModExprContext.prototype.constructor = ModExprContext;SmackParser.ModExprContext = ModExprContext;ModExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};ModExprContext.prototype.Mod = function(){return this.getToken(SmackParser.Mod,0);};ModExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterModExpr(this);}};ModExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitModExpr(this);}};ModExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitModExpr(this);}else {return visitor.visitChildren(this);}};function GtExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}GtExprContext.prototype = Object.create(ExpressionContext.prototype);GtExprContext.prototype.constructor = GtExprContext;SmackParser.GtExprContext = GtExprContext;GtExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};GtExprContext.prototype.Gt = function(){return this.getToken(SmackParser.Gt,0);};GtExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterGtExpr(this);}};GtExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitGtExpr(this);}};GtExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitGtExpr(this);}else {return visitor.visitChildren(this);}};function AtomExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}AtomExprContext.prototype = Object.create(ExpressionContext.prototype);AtomExprContext.prototype.constructor = AtomExprContext;SmackParser.AtomExprContext = AtomExprContext;AtomExprContext.prototype.resolvable = function(){return this.getTypedRuleContext(ResolvableContext,0);};AtomExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterAtomExpr(this);}};AtomExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitAtomExpr(this);}};AtomExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitAtomExpr(this);}else {return visitor.visitChildren(this);}};function OrExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}OrExprContext.prototype = Object.create(ExpressionContext.prototype);OrExprContext.prototype.constructor = OrExprContext;SmackParser.OrExprContext = OrExprContext;OrExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};OrExprContext.prototype.Or = function(){return this.getToken(SmackParser.Or,0);};OrExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterOrExpr(this);}};OrExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitOrExpr(this);}};OrExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitOrExpr(this);}else {return visitor.visitChildren(this);}};function ParenExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}ParenExprContext.prototype = Object.create(ExpressionContext.prototype);ParenExprContext.prototype.constructor = ParenExprContext;SmackParser.ParenExprContext = ParenExprContext;ParenExprContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};ParenExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterParenExpr(this);}};ParenExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitParenExpr(this);}};ParenExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitParenExpr(this);}else {return visitor.visitChildren(this);}};function NeqExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}NeqExprContext.prototype = Object.create(ExpressionContext.prototype);NeqExprContext.prototype.constructor = NeqExprContext;SmackParser.NeqExprContext = NeqExprContext;NeqExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};NeqExprContext.prototype.Neq = function(){return this.getToken(SmackParser.Neq,0);};NeqExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterNeqExpr(this);}};NeqExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitNeqExpr(this);}};NeqExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitNeqExpr(this);}else {return visitor.visitChildren(this);}};function EqExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}EqExprContext.prototype = Object.create(ExpressionContext.prototype);EqExprContext.prototype.constructor = EqExprContext;SmackParser.EqExprContext = EqExprContext;EqExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};EqExprContext.prototype.Eq = function(){return this.getToken(SmackParser.Eq,0);};EqExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterEqExpr(this);}};EqExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitEqExpr(this);}};EqExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitEqExpr(this);}else {return visitor.visitChildren(this);}};function LtExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}LtExprContext.prototype = Object.create(ExpressionContext.prototype);LtExprContext.prototype.constructor = LtExprContext;SmackParser.LtExprContext = LtExprContext;LtExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};LtExprContext.prototype.Lt = function(){return this.getToken(SmackParser.Lt,0);};LtExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterLtExpr(this);}};LtExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitLtExpr(this);}};LtExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitLtExpr(this);}else {return visitor.visitChildren(this);}};function NotExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}NotExprContext.prototype = Object.create(ExpressionContext.prototype);NotExprContext.prototype.constructor = NotExprContext;SmackParser.NotExprContext = NotExprContext;NotExprContext.prototype.Not = function(){return this.getToken(SmackParser.Not,0);};NotExprContext.prototype.expression = function(){return this.getTypedRuleContext(ExpressionContext,0);};NotExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterNotExpr(this);}};NotExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitNotExpr(this);}};NotExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitNotExpr(this);}else {return visitor.visitChildren(this);}};function SumExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}SumExprContext.prototype = Object.create(ExpressionContext.prototype);SumExprContext.prototype.constructor = SumExprContext;SmackParser.SumExprContext = SumExprContext;SumExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};SumExprContext.prototype.Plus = function(i){if(i === undefined){i = null;}if(i === null){return this.getTokens(SmackParser.Plus);}else {return this.getToken(SmackParser.Plus,i);}};SumExprContext.prototype.Minus = function(i){if(i === undefined){i = null;}if(i === null){return this.getTokens(SmackParser.Minus);}else {return this.getToken(SmackParser.Minus,i);}};SumExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterSumExpr(this);}};SumExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitSumExpr(this);}};SumExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitSumExpr(this);}else {return visitor.visitChildren(this);}};function LeExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}LeExprContext.prototype = Object.create(ExpressionContext.prototype);LeExprContext.prototype.constructor = LeExprContext;SmackParser.LeExprContext = LeExprContext;LeExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};LeExprContext.prototype.Le = function(){return this.getToken(SmackParser.Le,0);};LeExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterLeExpr(this);}};LeExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitLeExpr(this);}};LeExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitLeExpr(this);}else {return visitor.visitChildren(this);}};function MulExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}MulExprContext.prototype = Object.create(ExpressionContext.prototype);MulExprContext.prototype.constructor = MulExprContext;SmackParser.MulExprContext = MulExprContext;MulExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};MulExprContext.prototype.Mul = function(){return this.getToken(SmackParser.Mul,0);};MulExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterMulExpr(this);}};MulExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitMulExpr(this);}};MulExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitMulExpr(this);}else {return visitor.visitChildren(this);}};function DivExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}DivExprContext.prototype = Object.create(ExpressionContext.prototype);DivExprContext.prototype.constructor = DivExprContext;SmackParser.DivExprContext = DivExprContext;DivExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};DivExprContext.prototype.Div = function(){return this.getToken(SmackParser.Div,0);};DivExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterDivExpr(this);}};DivExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitDivExpr(this);}};DivExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitDivExpr(this);}else {return visitor.visitChildren(this);}};function PowExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}PowExprContext.prototype = Object.create(ExpressionContext.prototype);PowExprContext.prototype.constructor = PowExprContext;SmackParser.PowExprContext = PowExprContext;PowExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};PowExprContext.prototype.Pow = function(){return this.getToken(SmackParser.Pow,0);};PowExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterPowExpr(this);}};PowExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitPowExpr(this);}};PowExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitPowExpr(this);}else {return visitor.visitChildren(this);}};function AndExprContext(parser,ctx){ExpressionContext.call(this,parser);ExpressionContext.prototype.copyFrom.call(this,ctx);return this;}AndExprContext.prototype = Object.create(ExpressionContext.prototype);AndExprContext.prototype.constructor = AndExprContext;SmackParser.AndExprContext = AndExprContext;AndExprContext.prototype.expression = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ExpressionContext);}else {return this.getTypedRuleContext(ExpressionContext,i);}};AndExprContext.prototype.And = function(){return this.getToken(SmackParser.And,0);};AndExprContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterAndExpr(this);}};AndExprContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitAndExpr(this);}};AndExprContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitAndExpr(this);}else {return visitor.visitChildren(this);}};SmackParser.prototype.expression = function(_p){if(_p === undefined){_p = 0;}var _parentctx=this._ctx;var _parentState=this.state;var localctx=new ExpressionContext(this,this._ctx,_parentState);var _prevctx=localctx;var _startState=26;this.enterRecursionRule(localctx,26,SmackParser.RULE_expression,_p);var _la=0; // Token type\ntry{this.enterOuterAlt(localctx,1);this.state = 153;switch(this._input.LA(1)){case SmackParser.T__4:localctx = new ParenExprContext(this,localctx);this._ctx = localctx;_prevctx = localctx;this.state = 144;this.match(SmackParser.T__4);this.state = 145;this.expression(0);this.state = 146;this.match(SmackParser.T__6);break;case SmackParser.Minus:localctx = new SignedExprContext(this,localctx);this._ctx = localctx;_prevctx = localctx;this.state = 148;this.match(SmackParser.Minus);this.state = 149;this.expression(11);break;case SmackParser.Not:localctx = new NotExprContext(this,localctx);this._ctx = localctx;_prevctx = localctx;this.state = 150;this.match(SmackParser.Not);this.state = 151;this.expression(10);break;case SmackParser.T__8:case SmackParser.T__14:case SmackParser.T__17:case SmackParser.T__18:case SmackParser.T__19:case SmackParser.Id:case SmackParser.STRING:case SmackParser.NUMBER:localctx = new AtomExprContext(this,localctx);this._ctx = localctx;_prevctx = localctx;this.state = 152;this.resolvable();break;default:throw new antlr4.error.NoViableAltException(this);}this._ctx.stop = this._input.LT(-1);this.state = 200;this._errHandler.sync(this);var _alt=this._interp.adaptivePredict(this._input,12,this._ctx);while(_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER) {if(_alt === 1){if(this._parseListeners !== null){this.triggerExitRuleEvent();}_prevctx = localctx;this.state = 198;this._errHandler.sync(this);var la_=this._interp.adaptivePredict(this._input,11,this._ctx);switch(la_){case 1:localctx = new PowExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 155;if(!this.precpred(this._ctx,16)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 16)\");}this.state = 156;this.match(SmackParser.Pow);this.state = 157;this.expression(16);break;case 2:localctx = new MulExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 158;if(!this.precpred(this._ctx,15)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 15)\");}this.state = 159;this.match(SmackParser.Mul);this.state = 160;this.expression(16);break;case 3:localctx = new DivExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 161;if(!this.precpred(this._ctx,14)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 14)\");}this.state = 162;this.match(SmackParser.Div);this.state = 163;this.expression(15);break;case 4:localctx = new ModExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 164;if(!this.precpred(this._ctx,13)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 13)\");}this.state = 165;this.match(SmackParser.Mod);this.state = 166;this.expression(14);break;case 5:localctx = new SumExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 167;if(!this.precpred(this._ctx,12)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 12)\");}this.state = 169;this._errHandler.sync(this);var _alt=1;do {switch(_alt){case 1:this.state = 168;_la = this._input.LA(1);if(!(_la === SmackParser.Plus || _la === SmackParser.Minus)){this._errHandler.recoverInline(this);}else {this.consume();}break;default:throw new antlr4.error.NoViableAltException(this);}this.state = 171;this._errHandler.sync(this);_alt = this._interp.adaptivePredict(this._input,10,this._ctx);}while(_alt != 2 && _alt != antlr4.atn.ATN.INVALID_ALT_NUMBER);this.state = 173;this.expression(13);break;case 6:localctx = new EqExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 174;if(!this.precpred(this._ctx,9)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 9)\");}this.state = 175;this.match(SmackParser.Eq);this.state = 176;this.expression(10);break;case 7:localctx = new NeqExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 177;if(!this.precpred(this._ctx,8)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 8)\");}this.state = 178;this.match(SmackParser.Neq);this.state = 179;this.expression(9);break;case 8:localctx = new LtExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 180;if(!this.precpred(this._ctx,7)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 7)\");}this.state = 181;this.match(SmackParser.Lt);this.state = 182;this.expression(8);break;case 9:localctx = new LeExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 183;if(!this.precpred(this._ctx,6)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 6)\");}this.state = 184;this.match(SmackParser.Le);this.state = 185;this.expression(7);break;case 10:localctx = new GtExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 186;if(!this.precpred(this._ctx,5)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 5)\");}this.state = 187;this.match(SmackParser.Gt);this.state = 188;this.expression(6);break;case 11:localctx = new GeExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 189;if(!this.precpred(this._ctx,4)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 4)\");}this.state = 190;this.match(SmackParser.Ge);this.state = 191;this.expression(5);break;case 12:localctx = new AndExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 192;if(!this.precpred(this._ctx,3)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 3)\");}this.state = 193;this.match(SmackParser.And);this.state = 194;this.expression(4);break;case 13:localctx = new OrExprContext(this,new ExpressionContext(this,_parentctx,_parentState));this.pushNewRecursionContext(localctx,_startState,SmackParser.RULE_expression);this.state = 195;if(!this.precpred(this._ctx,2)){throw new antlr4.error.FailedPredicateException(this,\"this.precpred(this._ctx, 2)\");}this.state = 196;this.match(SmackParser.Or);this.state = 197;this.expression(3);break;}}this.state = 202;this._errHandler.sync(this);_alt = this._interp.adaptivePredict(this._input,12,this._ctx);}}catch(error) {if(error instanceof antlr4.error.RecognitionException){localctx.exception = error;this._errHandler.reportError(this,error);this._errHandler.recover(this,error);}else {throw error;}}finally {this.unrollRecursionContexts(_parentctx);}return localctx;};function ResolvableContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_resolvable;return this;}ResolvableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);ResolvableContext.prototype.constructor = ResolvableContext;ResolvableContext.prototype.value = function(){return this.getTypedRuleContext(ValueContext,0);};ResolvableContext.prototype.jsonPath = function(){return this.getTypedRuleContext(JsonPathContext,0);};ResolvableContext.prototype.funcInvoke = function(){return this.getTypedRuleContext(FuncInvokeContext,0);};ResolvableContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterResolvable(this);}};ResolvableContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitResolvable(this);}};ResolvableContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitResolvable(this);}else {return visitor.visitChildren(this);}};SmackParser.ResolvableContext = ResolvableContext;SmackParser.prototype.resolvable = function(){var localctx=new ResolvableContext(this,this._ctx,this.state);this.enterRule(localctx,28,SmackParser.RULE_resolvable);try{this.state = 206;this._errHandler.sync(this);var la_=this._interp.adaptivePredict(this._input,13,this._ctx);switch(la_){case 1:this.enterOuterAlt(localctx,1);this.state = 203;this.value();break;case 2:this.enterOuterAlt(localctx,2);this.state = 204;this.jsonPath();break;case 3:this.enterOuterAlt(localctx,3);this.state = 205;this.funcInvoke();break;}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function CodeBlockContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_codeBlock;return this;}CodeBlockContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);CodeBlockContext.prototype.constructor = CodeBlockContext;CodeBlockContext.prototype.sentence = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(SentenceContext);}else {return this.getTypedRuleContext(SentenceContext,i);}};CodeBlockContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterCodeBlock(this);}};CodeBlockContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitCodeBlock(this);}};CodeBlockContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitCodeBlock(this);}else {return visitor.visitChildren(this);}};SmackParser.CodeBlockContext = CodeBlockContext;SmackParser.prototype.codeBlock = function(){var localctx=new CodeBlockContext(this,this._ctx,this.state);this.enterRule(localctx,30,SmackParser.RULE_codeBlock);var _la=0; // Token type\ntry{this.enterOuterAlt(localctx,1);this.state = 208;this.match(SmackParser.T__14);this.state = 212;this._errHandler.sync(this);_la = this._input.LA(1);while((_la - 11 & ~0x1f) == 0 && (1 << _la - 11 & (1 << SmackParser.T__10 - 11 | 1 << SmackParser.T__11 - 11 | 1 << SmackParser.T__13 - 11 | 1 << SmackParser.Id - 11)) !== 0) {this.state = 209;this.sentence();this.state = 214;this._errHandler.sync(this);_la = this._input.LA(1);}this.state = 215;this.match(SmackParser.T__15);}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function SentenceContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_sentence;return this;}SentenceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);SentenceContext.prototype.constructor = SentenceContext;SentenceContext.prototype.statement = function(){return this.getTypedRuleContext(StatementContext,0);};SentenceContext.prototype.loop = function(){return this.getTypedRuleContext(LoopContext,0);};SentenceContext.prototype.ifStat = function(){return this.getTypedRuleContext(IfStatContext,0);};SentenceContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterSentence(this);}};SentenceContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitSentence(this);}};SentenceContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitSentence(this);}else {return visitor.visitChildren(this);}};SmackParser.SentenceContext = SentenceContext;SmackParser.prototype.sentence = function(){var localctx=new SentenceContext(this,this._ctx,this.state);this.enterRule(localctx,32,SmackParser.RULE_sentence);try{this.state = 222;switch(this._input.LA(1)){case SmackParser.T__10:case SmackParser.Id:this.enterOuterAlt(localctx,1);this.state = 217;this.statement();this.state = 218;this.match(SmackParser.T__1);break;case SmackParser.T__13:this.enterOuterAlt(localctx,2);this.state = 220;this.loop();break;case SmackParser.T__11:this.enterOuterAlt(localctx,3);this.state = 221;this.ifStat();break;default:throw new antlr4.error.NoViableAltException(this);}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function StatementContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_statement;return this;}StatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);StatementContext.prototype.constructor = StatementContext;StatementContext.prototype.varAssign = function(){return this.getTypedRuleContext(VarAssignContext,0);};StatementContext.prototype.funcInvoke = function(){return this.getTypedRuleContext(FuncInvokeContext,0);};StatementContext.prototype.retStatement = function(){return this.getTypedRuleContext(RetStatementContext,0);};StatementContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterStatement(this);}};StatementContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitStatement(this);}};StatementContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitStatement(this);}else {return visitor.visitChildren(this);}};SmackParser.StatementContext = StatementContext;SmackParser.prototype.statement = function(){var localctx=new StatementContext(this,this._ctx,this.state);this.enterRule(localctx,34,SmackParser.RULE_statement);try{this.state = 227;this._errHandler.sync(this);var la_=this._interp.adaptivePredict(this._input,16,this._ctx);switch(la_){case 1:this.enterOuterAlt(localctx,1);this.state = 224;this.varAssign();break;case 2:this.enterOuterAlt(localctx,2);this.state = 225;this.funcInvoke();break;case 3:this.enterOuterAlt(localctx,3);this.state = 226;this.retStatement();break;}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function JsonContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_json;return this;}JsonContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);JsonContext.prototype.constructor = JsonContext;JsonContext.prototype.object = function(){return this.getTypedRuleContext(ObjectContext,0);};JsonContext.prototype.array = function(){return this.getTypedRuleContext(ArrayContext,0);};JsonContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterJson(this);}};JsonContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitJson(this);}};JsonContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitJson(this);}else {return visitor.visitChildren(this);}};SmackParser.JsonContext = JsonContext;SmackParser.prototype.json = function(){var localctx=new JsonContext(this,this._ctx,this.state);this.enterRule(localctx,36,SmackParser.RULE_json);try{this.state = 231;switch(this._input.LA(1)){case SmackParser.T__14:this.enterOuterAlt(localctx,1);this.state = 229;this.object();break;case SmackParser.T__8:this.enterOuterAlt(localctx,2);this.state = 230;this.array();break;default:throw new antlr4.error.NoViableAltException(this);}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function ObjectContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_object;return this;}ObjectContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);ObjectContext.prototype.constructor = ObjectContext;ObjectContext.prototype.pair = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(PairContext);}else {return this.getTypedRuleContext(PairContext,i);}};ObjectContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterObject(this);}};ObjectContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitObject(this);}};ObjectContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitObject(this);}else {return visitor.visitChildren(this);}};SmackParser.ObjectContext = ObjectContext;SmackParser.prototype.object = function(){var localctx=new ObjectContext(this,this._ctx,this.state);this.enterRule(localctx,38,SmackParser.RULE_object);var _la=0; // Token type\ntry{this.state = 246;this._errHandler.sync(this);var la_=this._interp.adaptivePredict(this._input,19,this._ctx);switch(la_){case 1:this.enterOuterAlt(localctx,1);this.state = 233;this.match(SmackParser.T__14);this.state = 234;this.pair();this.state = 239;this._errHandler.sync(this);_la = this._input.LA(1);while(_la === SmackParser.T__5) {this.state = 235;this.match(SmackParser.T__5);this.state = 236;this.pair();this.state = 241;this._errHandler.sync(this);_la = this._input.LA(1);}this.state = 242;this.match(SmackParser.T__15);break;case 2:this.enterOuterAlt(localctx,2);this.state = 244;this.match(SmackParser.T__14);this.state = 245;this.match(SmackParser.T__15);break;}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function PairContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_pair;return this;}PairContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);PairContext.prototype.constructor = PairContext;PairContext.prototype.STRING = function(){return this.getToken(SmackParser.STRING,0);};PairContext.prototype.value = function(){return this.getTypedRuleContext(ValueContext,0);};PairContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterPair(this);}};PairContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitPair(this);}};PairContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitPair(this);}else {return visitor.visitChildren(this);}};SmackParser.PairContext = PairContext;SmackParser.prototype.pair = function(){var localctx=new PairContext(this,this._ctx,this.state);this.enterRule(localctx,40,SmackParser.RULE_pair);try{this.enterOuterAlt(localctx,1);this.state = 248;this.match(SmackParser.STRING);this.state = 249;this.match(SmackParser.T__16);this.state = 250;this.value();}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function ArrayContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_array;return this;}ArrayContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);ArrayContext.prototype.constructor = ArrayContext;ArrayContext.prototype.value = function(i){if(i === undefined){i = null;}if(i === null){return this.getTypedRuleContexts(ValueContext);}else {return this.getTypedRuleContext(ValueContext,i);}};ArrayContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterArray(this);}};ArrayContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitArray(this);}};ArrayContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitArray(this);}else {return visitor.visitChildren(this);}};SmackParser.ArrayContext = ArrayContext;SmackParser.prototype.array = function(){var localctx=new ArrayContext(this,this._ctx,this.state);this.enterRule(localctx,42,SmackParser.RULE_array);var _la=0; // Token type\ntry{this.state = 265;this._errHandler.sync(this);var la_=this._interp.adaptivePredict(this._input,21,this._ctx);switch(la_){case 1:this.enterOuterAlt(localctx,1);this.state = 252;this.match(SmackParser.T__8);this.state = 253;this.value();this.state = 258;this._errHandler.sync(this);_la = this._input.LA(1);while(_la === SmackParser.T__5) {this.state = 254;this.match(SmackParser.T__5);this.state = 255;this.value();this.state = 260;this._errHandler.sync(this);_la = this._input.LA(1);}this.state = 261;this.match(SmackParser.T__9);break;case 2:this.enterOuterAlt(localctx,2);this.state = 263;this.match(SmackParser.T__8);this.state = 264;this.match(SmackParser.T__9);break;}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};function ValueContext(parser,parent,invokingState){if(parent === undefined){parent = null;}if(invokingState === undefined || invokingState === null){invokingState = -1;}antlr4.ParserRuleContext.call(this,parent,invokingState);this.parser = parser;this.ruleIndex = SmackParser.RULE_value;return this;}ValueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);ValueContext.prototype.constructor = ValueContext;ValueContext.prototype.STRING = function(){return this.getToken(SmackParser.STRING,0);};ValueContext.prototype.NUMBER = function(){return this.getToken(SmackParser.NUMBER,0);};ValueContext.prototype.object = function(){return this.getTypedRuleContext(ObjectContext,0);};ValueContext.prototype.array = function(){return this.getTypedRuleContext(ArrayContext,0);};ValueContext.prototype.enterRule = function(listener){if(listener instanceof SmackListener){listener.enterValue(this);}};ValueContext.prototype.exitRule = function(listener){if(listener instanceof SmackListener){listener.exitValue(this);}};ValueContext.prototype.accept = function(visitor){if(visitor instanceof SmackVisitor){return visitor.visitValue(this);}else {return visitor.visitChildren(this);}};SmackParser.ValueContext = ValueContext;SmackParser.prototype.value = function(){var localctx=new ValueContext(this,this._ctx,this.state);this.enterRule(localctx,44,SmackParser.RULE_value);try{this.state = 274;switch(this._input.LA(1)){case SmackParser.STRING:this.enterOuterAlt(localctx,1);this.state = 267;this.match(SmackParser.STRING);break;case SmackParser.NUMBER:this.enterOuterAlt(localctx,2);this.state = 268;this.match(SmackParser.NUMBER);break;case SmackParser.T__14:this.enterOuterAlt(localctx,3);this.state = 269;this.object();break;case SmackParser.T__8:this.enterOuterAlt(localctx,4);this.state = 270;this.array();break;case SmackParser.T__17:this.enterOuterAlt(localctx,5);this.state = 271;this.match(SmackParser.T__17);break;case SmackParser.T__18:this.enterOuterAlt(localctx,6);this.state = 272;this.match(SmackParser.T__18);break;case SmackParser.T__19:this.enterOuterAlt(localctx,7);this.state = 273;this.match(SmackParser.T__19);break;default:throw new antlr4.error.NoViableAltException(this);}}catch(re) {if(re instanceof antlr4.error.RecognitionException){localctx.exception = re;this._errHandler.reportError(this,re);this._errHandler.recover(this,re);}else {throw re;}}finally {this.exitRule();}return localctx;};SmackParser.prototype.sempred = function(localctx,ruleIndex,predIndex){switch(ruleIndex){case 13:return this.expression_sempred(localctx,predIndex);default:throw \"No predicate with index:\" + ruleIndex;}};SmackParser.prototype.expression_sempred = function(localctx,predIndex){switch(predIndex){case 0:return this.precpred(this._ctx,16);case 1:return this.precpred(this._ctx,15);case 2:return this.precpred(this._ctx,14);case 3:return this.precpred(this._ctx,13);case 4:return this.precpred(this._ctx,12);case 5:return this.precpred(this._ctx,9);case 6:return this.precpred(this._ctx,8);case 7:return this.precpred(this._ctx,7);case 8:return this.precpred(this._ctx,6);case 9:return this.precpred(this._ctx,5);case 10:return this.precpred(this._ctx,4);case 11:return this.precpred(this._ctx,3);case 12:return this.precpred(this._ctx,2);default:throw \"No predicate with index:\" + predIndex;}};exports.SmackParser = SmackParser;\n},{\"./SmackListener\":52,\"./SmackVisitor\":54,\"antlr4\":41}],54:[function(require,module,exports){\n// Generated from ./Smack.g4 by ANTLR 4.5.3\n// jshint ignore: start\n'use strict';\n\nvar antlr4 = require('antlr4');\n\n// This class defines a complete generic visitor for a parse tree produced by SmackParser.\n\nfunction SmackVisitor() {\n\tantlr4.tree.ParseTreeVisitor.call(this);\n\treturn this;\n}\n\nSmackVisitor.prototype = Object.create(antlr4.tree.ParseTreeVisitor.prototype);\nSmackVisitor.prototype.constructor = SmackVisitor;\n\n// Visit a parse tree produced by SmackParser#smkFile.\nSmackVisitor.prototype.visitSmkFile = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#packageDecl.\nSmackVisitor.prototype.visitPackageDecl = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#varAssign.\nSmackVisitor.prototype.visitVarAssign = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#funcDecl.\nSmackVisitor.prototype.visitFuncDecl = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#funcInvoke.\nSmackVisitor.prototype.visitFuncInvoke = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#jsonPath.\nSmackVisitor.prototype.visitJsonPath = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#dottedId.\nSmackVisitor.prototype.visitDottedId = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#keyRef.\nSmackVisitor.prototype.visitKeyRef = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#retStatement.\nSmackVisitor.prototype.visitRetStatement = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#ifStat.\nSmackVisitor.prototype.visitIfStat = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#elseIfStat.\nSmackVisitor.prototype.visitElseIfStat = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#elseStat.\nSmackVisitor.prototype.visitElseStat = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#loop.\nSmackVisitor.prototype.visitLoop = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#signedExpr.\nSmackVisitor.prototype.visitSignedExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#geExpr.\nSmackVisitor.prototype.visitGeExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#modExpr.\nSmackVisitor.prototype.visitModExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#gtExpr.\nSmackVisitor.prototype.visitGtExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#atomExpr.\nSmackVisitor.prototype.visitAtomExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#orExpr.\nSmackVisitor.prototype.visitOrExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#parenExpr.\nSmackVisitor.prototype.visitParenExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#neqExpr.\nSmackVisitor.prototype.visitNeqExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#eqExpr.\nSmackVisitor.prototype.visitEqExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#ltExpr.\nSmackVisitor.prototype.visitLtExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#notExpr.\nSmackVisitor.prototype.visitNotExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#sumExpr.\nSmackVisitor.prototype.visitSumExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#leExpr.\nSmackVisitor.prototype.visitLeExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#mulExpr.\nSmackVisitor.prototype.visitMulExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#divExpr.\nSmackVisitor.prototype.visitDivExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#powExpr.\nSmackVisitor.prototype.visitPowExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#andExpr.\nSmackVisitor.prototype.visitAndExpr = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#resolvable.\nSmackVisitor.prototype.visitResolvable = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#codeBlock.\nSmackVisitor.prototype.visitCodeBlock = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#sentence.\nSmackVisitor.prototype.visitSentence = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#statement.\nSmackVisitor.prototype.visitStatement = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#json.\nSmackVisitor.prototype.visitJson = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#object.\nSmackVisitor.prototype.visitObject = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#pair.\nSmackVisitor.prototype.visitPair = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#array.\nSmackVisitor.prototype.visitArray = function (ctx) {};\n\n// Visit a parse tree produced by SmackParser#value.\nSmackVisitor.prototype.visitValue = function (ctx) {};\n\nexports.SmackVisitor = SmackVisitor;\n},{\"antlr4\":41}],55:[function(require,module,exports){\n'use strict';\n\nmodule.exports.extend = function (mc) {\n\t// Standard methods\n\tif (!mc._f || typeof mc._f !== 'object') mc._f = {};\n\tmc._f.exec = function (func, args) {\n\t\tvar ids = func.split('.');\n\t\tvar callString = 'mc.' + ids.slice(0, ids.length - 1).join('.') + '._f.' + ids[ids.length - 1];\n\t\tif (args) return eval(callString + '.apply(undefined, args)');else return eval(callString + '.apply(undefined)');\n\t};\n\tmc._f.wait = function (millis) {\n\t\tthrow 'wait hasn\\'t been implemented in the browser standard library';\n\t};\n\n\t// Standard array methods\n\tif (!mc.ary || typeof mc.ary !== 'object') mc.ary = {};\n\tif (!mc.ary._f || typeof mc.ary._f !== 'object') mc.ary._f = {};\n\tmc.ary._f.length = function (ary) {\n\t\treturn ary.length;\n\t};\n};\n},{}]},{},[46])"]}