diff --git a/src/vtlengine/AST/ASTConstructorModules/Expr.py b/src/vtlengine/AST/ASTConstructorModules/Expr.py index 97b3cb544..b730017bf 100644 --- a/src/vtlengine/AST/ASTConstructorModules/Expr.py +++ b/src/vtlengine/AST/ASTConstructorModules/Expr.py @@ -1886,6 +1886,8 @@ def visitSubspaceClauseItem(self, ctx: Parser.SubspaceClauseItemContext): op_node = ctx_list[1].getSymbol().text if isinstance(ctx_list[2], Parser.ScalarWithCastContext): right_node = Terminals().visitScalarWithCast(ctx_list[2]) + elif isinstance(ctx_list[2], Parser.ScalarVarWithCastContext): + right_node = Terminals().visitScalarVarWithCast(ctx_list[2]) elif isinstance(ctx_list[2], Parser.ScalarItemContext): right_node = Terminals().visitScalarItem(ctx_list[2]) else: diff --git a/src/vtlengine/AST/ASTConstructorModules/Terminals.py b/src/vtlengine/AST/ASTConstructorModules/Terminals.py index 712f0acd4..55d4878d6 100644 --- a/src/vtlengine/AST/ASTConstructorModules/Terminals.py +++ b/src/vtlengine/AST/ASTConstructorModules/Terminals.py @@ -512,6 +512,8 @@ def visitScalarItem(self, ctx: Parser.ScalarItemContext): return self.visitConstant(c) elif isinstance(c, Parser.ScalarWithCastContext): return self.visitScalarWithCast(c) + elif isinstance(c, Parser.ScalarVarWithCastContext): + return self.visitScalarVarWithCast(c) else: raise NotImplementedError @@ -549,6 +551,40 @@ def visitScalarWithCast(self, ctx: Parser.ScalarWithCastContext): # AST_ASTCONSTRUCTOR.14 raise NotImplementedError + def visitScalarVarWithCast(self, ctx: Parser.ScalarVarWithCastContext): + """ + | CAST LPAREN varID COMMA (basicScalarType) (COMMA STRING_CONSTANT)? RPAREN #scalarVarWithCast + """ # noqa E501 + ctx_list = list(ctx.getChildren()) + c = ctx_list[0] + + token = c.getSymbol() + + op = token.text + var_node = self.visitVarID(ctx_list[2]) + basic_scalar_type = [self.visitBasicScalarType(ctx_list[4])] + + param_node = ( + [ + ParamConstant( + type_="PARAM_CAST", value=ctx_list[6], **extract_token_info(ctx_list[6]) + ) + ] + if len(ctx_list) > 6 + else [] + ) + + if len(basic_scalar_type) == 1: + children_nodes = [var_node, basic_scalar_type[0]] + + return ParamOp( + op=op, children=children_nodes, params=param_node, **extract_token_info(ctx) + ) + + else: + # AST_ASTCONSTRUCTOR.14 + raise NotImplementedError + def visitScalarSetType(self, ctx: Parser.ScalarSetTypeContext): """ scalarSetType: SET ('<' scalarType '>')? ; diff --git a/src/vtlengine/AST/Grammar/Vtl.g4 b/src/vtlengine/AST/Grammar/Vtl.g4 index 7b2cbbb6d..8614aede4 100644 --- a/src/vtlengine/AST/Grammar/Vtl.g4 +++ b/src/vtlengine/AST/Grammar/Vtl.g4 @@ -369,6 +369,7 @@ subspaceClauseItem: scalarItem: constant #simpleScalar | CAST LPAREN constant COMMA (basicScalarType) (COMMA STRING_CONSTANT)? RPAREN #scalarWithCast + | CAST LPAREN varID COMMA (basicScalarType) (COMMA STRING_CONSTANT)? RPAREN #scalarVarWithCast ; /*END SUBSPACE CLAUSE*/ /*----------------------------------------------END CLAUSE EXPRESSION--------------------------------------*/ diff --git a/src/vtlengine/AST/Grammar/lexer.py b/src/vtlengine/AST/Grammar/lexer.py index b7cf9ab69..87526aac9 100644 --- a/src/vtlengine/AST/Grammar/lexer.py +++ b/src/vtlengine/AST/Grammar/lexer.py @@ -1,4 +1,4 @@ -# Generated from Vtl.g4 by ANTLR 4.9.2 +# Generated from Vtl.g4 by ANTLR 4.9.3 from antlr4 import ( Lexer as ANTLRLexer, ATNDeserializer, @@ -2132,6 +2132,7 @@ class Lexer(ANTLRLexer): def __init__(self, input=None, output: TextIO = sys.stdout): super().__init__(input, output) + self.checkVersion("4.9.3") self._interp = LexerATNSimulator( self, self.atn, self.decisionsToDFA, PredictionContextCache() ) diff --git a/src/vtlengine/AST/Grammar/parser.py b/src/vtlengine/AST/Grammar/parser.py index 5522db123..d1b074ba6 100644 --- a/src/vtlengine/AST/Grammar/parser.py +++ b/src/vtlengine/AST/Grammar/parser.py @@ -1,19 +1,22 @@ -# Generated from Vtl.g4 by ANTLR 4.9.2 +# Generated from Vtl.g4 by ANTLR 4.9.3 # encoding: utf-8 +from typing import Any + from antlr4 import * from antlr4 import Parser as ANTLRParser from io import StringIO import sys -from typing import TextIO, Any -from antlr4.atn.ATN import ATN -from antlr4.tree.Tree import ParseTreeListener +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO # type: ignore def serializedATN(): with StringIO() as buf: buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00fb") - buf.write("\u073e\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") + buf.write("\u0749\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7") buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16") buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23") buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31") @@ -137,506 +140,507 @@ def serializedATN(): buf.write("\3'\3'\3'\3'\3'\5'\u0532\n'\3(\3(\3(\3(\3)\3)\3") buf.write(")\7)\u053b\n)\f)\16)\u053e\13)\3*\5*\u0541\n*\3*\3*\3") buf.write("*\3*\3+\5+\u0548\n+\3+\3+\3+\3+\3,\3,\3,\3,\5,\u0552\n") - buf.write(",\3-\3-\3-\3-\3-\3-\3-\3-\5-\u055c\n-\3-\3-\5-\u0560\n") - buf.write("-\3.\3.\3.\7.\u0565\n.\f.\16.\u0568\13.\3/\3/\3/\7/\u056d") - buf.write("\n/\f/\16/\u0570\13/\3/\3/\3/\3/\7/\u0576\n/\f/\16/\u0579") - buf.write("\13/\5/\u057b\n/\3\60\3\60\3\60\5\60\u0580\n\60\3\61\5") - buf.write("\61\u0583\n\61\3\61\3\61\3\61\5\61\u0588\n\61\3\61\5\61") - buf.write("\u058b\n\61\3\61\5\61\u058e\n\61\3\62\3\62\3\62\3\63\3") - buf.write("\63\3\63\3\63\3\63\7\63\u0598\n\63\f\63\16\63\u059b\13") - buf.write("\63\3\64\3\64\3\64\3\64\3\64\7\64\u05a2\n\64\f\64\16\64") - buf.write("\u05a5\13\64\3\65\3\65\5\65\u05a9\n\65\3\66\3\66\3\66") - buf.write("\5\66\u05ae\n\66\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3") - buf.write("8\38\38\38\38\38\38\38\38\38\38\58\u05c2\n8\39\39\39\3") - buf.write("9\39\79\u05c9\n9\f9\169\u05cc\139\39\39\39\59\u05d1\n") - buf.write("9\3:\3:\3:\3;\3;\3;\3;\5;\u05da\n;\3<\3<\3<\5<\u05df\n") - buf.write("<\3=\3=\5=\u05e3\n=\3>\3>\3>\3>\3>\5>\u05ea\n>\3?\3?\3") - buf.write("?\5?\u05ef\n?\3@\3@\5@\u05f3\n@\3@\5@\u05f6\n@\3@\5@\u05f9") - buf.write("\n@\3@\5@\u05fc\n@\3A\3A\3A\3A\3A\5A\u0603\nA\3B\3B\3") - buf.write("B\3B\3B\7B\u060a\nB\fB\16B\u060d\13B\3B\3B\5B\u0611\n") - buf.write("B\3C\3C\5C\u0615\nC\3D\3D\3D\3D\3D\5D\u061c\nD\3E\3E\3") - buf.write("E\3E\3E\3E\7E\u0624\nE\fE\16E\u0627\13E\3E\3E\5E\u062b") - buf.write("\nE\3E\3E\3E\3E\3E\7E\u0632\nE\fE\16E\u0635\13E\3E\3E") - buf.write("\5E\u0639\nE\5E\u063b\nE\3F\3F\3F\3F\3F\3F\3F\3F\7F\u0645") - buf.write("\nF\fF\16F\u0648\13F\3F\3F\5F\u064c\nF\3F\5F\u064f\nF") - buf.write("\3F\3F\3F\3F\3F\3F\3F\7F\u0658\nF\fF\16F\u065b\13F\3F") - buf.write("\3F\5F\u065f\nF\3F\3F\5F\u0663\nF\5F\u0665\nF\3G\3G\3") - buf.write("H\3H\3I\3I\3I\3I\7I\u066f\nI\fI\16I\u0672\13I\3J\3J\3") - buf.write("J\5J\u0677\nJ\3K\3K\3K\7K\u067c\nK\fK\16K\u067f\13K\3") - buf.write("L\3L\5L\u0683\nL\3L\3L\3L\3L\5L\u0689\nL\3L\3L\5L\u068d") - buf.write("\nL\3L\5L\u0690\nL\3M\3M\3M\7M\u0695\nM\fM\16M\u0698\13") - buf.write("M\3N\3N\5N\u069c\nN\3N\3N\5N\u06a0\nN\3N\5N\u06a3\nN\3") - buf.write("O\3O\3O\5O\u06a8\nO\3O\3O\3O\3P\3P\3P\7P\u06b0\nP\fP\16") - buf.write("P\u06b3\13P\3Q\3Q\3Q\3Q\5Q\u06b9\nQ\3Q\3Q\5Q\u06bd\nQ") - buf.write("\3Q\3Q\7Q\u06c1\nQ\fQ\16Q\u06c4\13Q\3R\5R\u06c7\nR\3R") - buf.write("\3R\3R\3R\3R\5R\u06ce\nR\3S\3S\3T\3T\3T\3T\3T\3T\3T\3") - buf.write("T\7T\u06da\nT\fT\16T\u06dd\13T\3T\3T\5T\u06e1\nT\3U\3") - buf.write("U\3U\5U\u06e6\nU\3V\3V\5V\u06ea\nV\3W\3W\3X\3X\3Y\3Y\3") - buf.write("Y\3Y\7Y\u06f4\nY\fY\16Y\u06f7\13Y\3Z\3Z\3[\3[\3[\3\\\3") - buf.write("\\\3]\3]\3^\3^\3_\3_\3`\3`\3a\3a\3a\5a\u070b\na\3b\3b") - buf.write("\3b\3b\7b\u0711\nb\fb\16b\u0714\13b\3b\3b\3c\3c\3c\3d") - buf.write("\3d\3d\3e\3e\3f\3f\5f\u0722\nf\3g\3g\5g\u0726\ng\3h\3") - buf.write("h\3h\3h\3h\5h\u072d\nh\3i\3i\3i\3j\3j\3k\3k\3l\3l\3m\3") - buf.write("m\3n\3n\3o\3o\3o\2\4\6\bp\2\4\6\b\n\f\16\20\22\24\26\30") - buf.write('\32\34\36 "$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b') - buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c") - buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e") - buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0") - buf.write("\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2") - buf.write("\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4") - buf.write("\u00d6\u00d8\u00da\u00dc\2'\4\2\17\20\64\64\3\2\21\22") - buf.write("\4\2\17\20``\3\2\62\63\3\2\66\67\3\2+,\4\2\u00cc\u00cc") - buf.write("\u00ce\u00ce\3\2\u00c3\u00c4\3\2\u00c5\u00c6\5\2__ac\u0085") - buf.write("\u0086\6\2WWYYnn\u0089\u008b\3\2[\\\5\2??ZZ]^\4\2JJ\u00d3") - buf.write("\u00d3\3\2\u00a4\u00a5\4\2uu\u00f6\u00f6\3\2TU\4\2==\u008d") - buf.write("\u008d\4\2JJvv\5\2RSeh\u008e\u0091\6\2RSeh\u008e\u0091") - buf.write("\u0095\u0096\3\2\u0097\u0098\3\2PQ\4\2NN\u0093\u0093\3") - buf.write("\2wx\3\2\17\20\4\2\u00f3\u00f4\u00f7\u00f7\4\2\17\17\21") - buf.write("\21\5\2JJvv\u00ea\u00ea\3\2\u00e3\u00e8\4\2{{\u00de\u00de") - buf.write("\5\2{{\u0082\u0082\u00dd\u00dd\4\2JJ\u00e2\u00e2\3\2\t") - buf.write("\16\4\288\u00f3\u00f6\5\2\u00aa\u00b0\u00d4\u00d4\u00eb") - buf.write("\u00eb\4\2JJ\u00f5\u00f5\2\u07fa\2\u00e3\3\2\2\2\4\u00f1") - buf.write("\3\2\2\2\6\u0111\3\2\2\2\b\u0154\3\2\2\2\n\u0179\3\2\2") - buf.write("\2\f\u0187\3\2\2\2\16\u0190\3\2\2\2\20\u0192\3\2\2\2\22") - buf.write("\u019b\3\2\2\2\24\u01a3\3\2\2\2\26\u01a6\3\2\2\2\30\u01af") - buf.write("\3\2\2\2\32\u01b8\3\2\2\2\34\u01bd\3\2\2\2\36\u01ca\3") - buf.write('\2\2\2 \u01df\3\2\2\2"\u0213\3\2\2\2$\u024e\3\2\2\2&') - buf.write("\u0289\3\2\2\2(\u028d\3\2\2\2*\u0291\3\2\2\2,\u02c3\3") - buf.write("\2\2\2.\u02f5\3\2\2\2\60\u030c\3\2\2\2\62\u0323\3\2\2") - buf.write("\2\64\u0345\3\2\2\2\66\u035c\3\2\2\28\u03c4\3\2\2\2:\u042c") - buf.write("\3\2\2\2<\u044b\3\2\2\2>\u044d\3\2\2\2@\u04a1\3\2\2\2") - buf.write("B\u04a3\3\2\2\2D\u04aa\3\2\2\2F\u04b9\3\2\2\2H\u04bb\3") - buf.write("\2\2\2J\u04f5\3\2\2\2L\u0531\3\2\2\2N\u0533\3\2\2\2P\u0537") - buf.write("\3\2\2\2R\u0540\3\2\2\2T\u0547\3\2\2\2V\u054d\3\2\2\2") - buf.write("X\u055f\3\2\2\2Z\u0561\3\2\2\2\\\u0569\3\2\2\2^\u057c") - buf.write("\3\2\2\2`\u0582\3\2\2\2b\u058f\3\2\2\2d\u0592\3\2\2\2") - buf.write("f\u059c\3\2\2\2h\u05a6\3\2\2\2j\u05ad\3\2\2\2l\u05b4\3") - buf.write("\2\2\2n\u05c1\3\2\2\2p\u05d0\3\2\2\2r\u05d2\3\2\2\2t\u05d5") - buf.write("\3\2\2\2v\u05de\3\2\2\2x\u05e2\3\2\2\2z\u05e9\3\2\2\2") - buf.write("|\u05ee\3\2\2\2~\u05f2\3\2\2\2\u0080\u05fd\3\2\2\2\u0082") - buf.write("\u0604\3\2\2\2\u0084\u0614\3\2\2\2\u0086\u0616\3\2\2\2") - buf.write("\u0088\u063a\3\2\2\2\u008a\u0664\3\2\2\2\u008c\u0666\3") - buf.write("\2\2\2\u008e\u0668\3\2\2\2\u0090\u066a\3\2\2\2\u0092\u0673") - buf.write("\3\2\2\2\u0094\u0678\3\2\2\2\u0096\u0682\3\2\2\2\u0098") - buf.write("\u0691\3\2\2\2\u009a\u069b\3\2\2\2\u009c\u06a4\3\2\2\2") - buf.write("\u009e\u06ac\3\2\2\2\u00a0\u06b8\3\2\2\2\u00a2\u06c6\3") - buf.write("\2\2\2\u00a4\u06cf\3\2\2\2\u00a6\u06e0\3\2\2\2\u00a8\u06e2") - buf.write("\3\2\2\2\u00aa\u06e7\3\2\2\2\u00ac\u06eb\3\2\2\2\u00ae") - buf.write("\u06ed\3\2\2\2\u00b0\u06ef\3\2\2\2\u00b2\u06f8\3\2\2\2") - buf.write("\u00b4\u06fa\3\2\2\2\u00b6\u06fd\3\2\2\2\u00b8\u06ff\3") - buf.write("\2\2\2\u00ba\u0701\3\2\2\2\u00bc\u0703\3\2\2\2\u00be\u0705") - buf.write("\3\2\2\2\u00c0\u0707\3\2\2\2\u00c2\u070c\3\2\2\2\u00c4") - buf.write("\u0717\3\2\2\2\u00c6\u071a\3\2\2\2\u00c8\u071d\3\2\2\2") - buf.write("\u00ca\u0721\3\2\2\2\u00cc\u0725\3\2\2\2\u00ce\u072c\3") - buf.write("\2\2\2\u00d0\u072e\3\2\2\2\u00d2\u0731\3\2\2\2\u00d4\u0733") - buf.write("\3\2\2\2\u00d6\u0735\3\2\2\2\u00d8\u0737\3\2\2\2\u00da") - buf.write("\u0739\3\2\2\2\u00dc\u073b\3\2\2\2\u00de\u00df\5\4\3\2") - buf.write("\u00df\u00e0\7\u00f9\2\2\u00e0\u00e2\3\2\2\2\u00e1\u00de") - buf.write("\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e3") - buf.write("\u00e4\3\2\2\2\u00e4\u00e6\3\2\2\2\u00e5\u00e3\3\2\2\2") - buf.write("\u00e6\u00e7\7\2\2\3\u00e7\3\3\2\2\2\u00e8\u00e9\5\u00bc") - buf.write("_\2\u00e9\u00ea\7\26\2\2\u00ea\u00eb\5\6\4\2\u00eb\u00f2") - buf.write("\3\2\2\2\u00ec\u00ed\5\u00bc_\2\u00ed\u00ee\7~\2\2\u00ee") - buf.write('\u00ef\5\6\4\2\u00ef\u00f2\3\2\2\2\u00f0\u00f2\5"\22') - buf.write("\2\u00f1\u00e8\3\2\2\2\u00f1\u00ec\3\2\2\2\u00f1\u00f0") - buf.write("\3\2\2\2\u00f2\5\3\2\2\2\u00f3\u00f4\b\4\1\2\u00f4\u00f5") - buf.write("\7\3\2\2\u00f5\u00f6\5\6\4\2\u00f6\u00f7\7\4\2\2\u00f7") - buf.write("\u0112\3\2\2\2\u00f8\u0112\5\f\7\2\u00f9\u00fa\t\2\2\2") - buf.write("\u00fa\u0112\5\6\4\r\u00fb\u00fc\7\31\2\2\u00fc\u00fd") - buf.write("\5\6\4\2\u00fd\u00fe\7\33\2\2\u00fe\u00ff\5\6\4\2\u00ff") - buf.write("\u0100\7\34\2\2\u0100\u0101\5\6\4\6\u0101\u0112\3\2\2") - buf.write("\2\u0102\u0108\7\32\2\2\u0103\u0104\7\u00bb\2\2\u0104") - buf.write("\u0105\5\6\4\2\u0105\u0106\7\33\2\2\u0106\u0107\5\6\4") - buf.write("\2\u0107\u0109\3\2\2\2\u0108\u0103\3\2\2\2\u0109\u010a") - buf.write("\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b") - buf.write("\u010c\3\2\2\2\u010c\u010d\7\34\2\2\u010d\u010e\5\6\4") - buf.write("\5\u010e\u0112\3\2\2\2\u010f\u0112\5\u00d8m\2\u0110\u0112") - buf.write("\5\u00bc_\2\u0111\u00f3\3\2\2\2\u0111\u00f8\3\2\2\2\u0111") - buf.write("\u00f9\3\2\2\2\u0111\u00fb\3\2\2\2\u0111\u0102\3\2\2\2") - buf.write("\u0111\u010f\3\2\2\2\u0111\u0110\3\2\2\2\u0112\u0133\3") - buf.write("\2\2\2\u0113\u0114\f\f\2\2\u0114\u0115\t\3\2\2\u0115\u0132") - buf.write("\5\6\4\r\u0116\u0117\f\13\2\2\u0117\u0118\t\4\2\2\u0118") - buf.write("\u0132\5\6\4\f\u0119\u011a\f\n\2\2\u011a\u011b\5\u00c8") - buf.write("e\2\u011b\u011c\5\6\4\13\u011c\u0132\3\2\2\2\u011d\u011e") - buf.write("\f\b\2\2\u011e\u011f\7\61\2\2\u011f\u0132\5\6\4\t\u0120") - buf.write("\u0121\f\7\2\2\u0121\u0122\t\5\2\2\u0122\u0132\5\6\4\b") - buf.write("\u0123\u0124\f\17\2\2\u0124\u0125\7\5\2\2\u0125\u0126") - buf.write("\5\16\b\2\u0126\u0127\7\6\2\2\u0127\u0132\3\2\2\2\u0128") - buf.write("\u0129\f\16\2\2\u0129\u012a\7\27\2\2\u012a\u0132\5\u00be") - buf.write("`\2\u012b\u012c\f\t\2\2\u012c\u012f\t\6\2\2\u012d\u0130") - buf.write("\5\u00c2b\2\u012e\u0130\5\u00d2j\2\u012f\u012d\3\2\2\2") - buf.write("\u012f\u012e\3\2\2\2\u0130\u0132\3\2\2\2\u0131\u0113\3") - buf.write("\2\2\2\u0131\u0116\3\2\2\2\u0131\u0119\3\2\2\2\u0131\u011d") - buf.write("\3\2\2\2\u0131\u0120\3\2\2\2\u0131\u0123\3\2\2\2\u0131") - buf.write("\u0128\3\2\2\2\u0131\u012b\3\2\2\2\u0132\u0135\3\2\2\2") - buf.write("\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134\7\3\2\2") - buf.write("\2\u0135\u0133\3\2\2\2\u0136\u0137\b\5\1\2\u0137\u0138") - buf.write("\7\3\2\2\u0138\u0139\5\b\5\2\u0139\u013a\7\4\2\2\u013a") - buf.write("\u0155\3\2\2\2\u013b\u0155\5\n\6\2\u013c\u013d\t\2\2\2") - buf.write("\u013d\u0155\5\b\5\r\u013e\u013f\7\31\2\2\u013f\u0140") - buf.write("\5\b\5\2\u0140\u0141\7\33\2\2\u0141\u0142\5\b\5\2\u0142") - buf.write("\u0143\7\34\2\2\u0143\u0144\5\b\5\6\u0144\u0155\3\2\2") - buf.write("\2\u0145\u014b\7\32\2\2\u0146\u0147\7\u00bb\2\2\u0147") - buf.write("\u0148\5\b\5\2\u0148\u0149\7\33\2\2\u0149\u014a\5\b\5") - buf.write("\2\u014a\u014c\3\2\2\2\u014b\u0146\3\2\2\2\u014c\u014d") - buf.write("\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e") - buf.write("\u014f\3\2\2\2\u014f\u0150\7\34\2\2\u0150\u0151\5\b\5") - buf.write("\5\u0151\u0155\3\2\2\2\u0152\u0155\5\u00d8m\2\u0153\u0155") - buf.write("\5\u00c0a\2\u0154\u0136\3\2\2\2\u0154\u013b\3\2\2\2\u0154") - buf.write("\u013c\3\2\2\2\u0154\u013e\3\2\2\2\u0154\u0145\3\2\2\2") - buf.write("\u0154\u0152\3\2\2\2\u0154\u0153\3\2\2\2\u0155\u016e\3") - buf.write("\2\2\2\u0156\u0157\f\f\2\2\u0157\u0158\t\3\2\2\u0158\u016d") - buf.write("\5\b\5\r\u0159\u015a\f\13\2\2\u015a\u015b\t\4\2\2\u015b") - buf.write("\u016d\5\b\5\f\u015c\u015d\f\n\2\2\u015d\u015e\5\u00c8") - buf.write("e\2\u015e\u015f\5\b\5\13\u015f\u016d\3\2\2\2\u0160\u0161") - buf.write("\f\b\2\2\u0161\u0162\7\61\2\2\u0162\u016d\5\b\5\t\u0163") - buf.write("\u0164\f\7\2\2\u0164\u0165\t\5\2\2\u0165\u016d\5\b\5\b") - buf.write("\u0166\u0167\f\t\2\2\u0167\u016a\t\6\2\2\u0168\u016b\5") - buf.write("\u00c2b\2\u0169\u016b\5\u00d2j\2\u016a\u0168\3\2\2\2\u016a") - buf.write("\u0169\3\2\2\2\u016b\u016d\3\2\2\2\u016c\u0156\3\2\2\2") - buf.write("\u016c\u0159\3\2\2\2\u016c\u015c\3\2\2\2\u016c\u0160\3") - buf.write("\2\2\2\u016c\u0163\3\2\2\2\u016c\u0166\3\2\2\2\u016d\u0170") - buf.write("\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f") - buf.write("\t\3\2\2\2\u0170\u016e\3\2\2\2\u0171\u017a\5&\24\2\u0172") - buf.write("\u017a\5.\30\2\u0173\u017a\5\62\32\2\u0174\u017a\5\66") - buf.write("\34\2\u0175\u017a\5:\36\2\u0176\u017a\5D#\2\u0177\u017a") - buf.write("\5F$\2\u0178\u017a\5L'\2\u0179\u0171\3\2\2\2\u0179\u0172") - buf.write("\3\2\2\2\u0179\u0173\3\2\2\2\u0179\u0174\3\2\2\2\u0179") - buf.write("\u0175\3\2\2\2\u0179\u0176\3\2\2\2\u0179\u0177\3\2\2\2") - buf.write("\u0179\u0178\3\2\2\2\u017a\13\3\2\2\2\u017b\u0188\5 \21") - buf.write("\2\u017c\u0188\5$\23\2\u017d\u0188\5,\27\2\u017e\u0188") - buf.write("\5\60\31\2\u017f\u0188\5\64\33\2\u0180\u0188\58\35\2\u0181") - buf.write("\u0188\5<\37\2\u0182\u0188\5> \2\u0183\u0188\5@!\2\u0184") - buf.write('\u0188\5B"\2\u0185\u0188\5H%\2\u0186\u0188\5J&\2\u0187') - buf.write("\u017b\3\2\2\2\u0187\u017c\3\2\2\2\u0187\u017d\3\2\2\2") - buf.write("\u0187\u017e\3\2\2\2\u0187\u017f\3\2\2\2\u0187\u0180\3") - buf.write("\2\2\2\u0187\u0181\3\2\2\2\u0187\u0182\3\2\2\2\u0187\u0183") - buf.write("\3\2\2\2\u0187\u0184\3\2\2\2\u0187\u0185\3\2\2\2\u0187") - buf.write("\u0186\3\2\2\2\u0188\r\3\2\2\2\u0189\u0191\5\20\t\2\u018a") - buf.write("\u0191\5\22\n\2\u018b\u0191\5\24\13\2\u018c\u0191\5\26") - buf.write("\f\2\u018d\u0191\5\30\r\2\u018e\u0191\5\32\16\2\u018f") - buf.write("\u0191\5\36\20\2\u0190\u0189\3\2\2\2\u0190\u018a\3\2\2") - buf.write("\2\u0190\u018b\3\2\2\2\u0190\u018c\3\2\2\2\u0190\u018d") - buf.write("\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u018f\3\2\2\2\u0191") - buf.write("\17\3\2\2\2\u0192\u0193\7/\2\2\u0193\u0198\5N(\2\u0194") - buf.write("\u0195\7\23\2\2\u0195\u0197\5N(\2\u0196\u0194\3\2\2\2") - buf.write("\u0197\u019a\3\2\2\2\u0198\u0196\3\2\2\2\u0198\u0199\3") - buf.write("\2\2\2\u0199\21\3\2\2\2\u019a\u0198\3\2\2\2\u019b\u019c") - buf.write("\7K\2\2\u019c\u01a1\5P)\2\u019d\u019f\5p9\2\u019e\u01a0") - buf.write("\5r:\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2") - buf.write("\3\2\2\2\u01a1\u019d\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2") - buf.write("\23\3\2\2\2\u01a3\u01a4\7l\2\2\u01a4\u01a5\5\b\5\2\u01a5") - buf.write("\25\3\2\2\2\u01a6\u01a7\7-\2\2\u01a7\u01ac\5T+\2\u01a8") - buf.write("\u01a9\7\23\2\2\u01a9\u01ab\5T+\2\u01aa\u01a8\3\2\2\2") - buf.write("\u01ab\u01ae\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac\u01ad\3") - buf.write("\2\2\2\u01ad\27\3\2\2\2\u01ae\u01ac\3\2\2\2\u01af\u01b0") - buf.write("\t\7\2\2\u01b0\u01b5\5\u00c0a\2\u01b1\u01b2\7\23\2\2\u01b2") - buf.write("\u01b4\5\u00c0a\2\u01b3\u01b1\3\2\2\2\u01b4\u01b7\3\2") - buf.write("\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\31") - buf.write("\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01b9\t\b\2\2\u01b9") - buf.write("\u01ba\5\u00c0a\2\u01ba\u01bb\7\23\2\2\u01bb\u01bc\5\u00c0") - buf.write("a\2\u01bc\33\3\2\2\2\u01bd\u01be\7\u00cd\2\2\u01be\u01bf") - buf.write("\5\u00c0a\2\u01bf\u01c0\7\23\2\2\u01c0\u01c1\5\u00c0a") - buf.write("\2\u01c1\u01c2\7\66\2\2\u01c2\u01c7\5\u00d8m\2\u01c3\u01c4") - buf.write("\7\23\2\2\u01c4\u01c6\5\u00d8m\2\u01c5\u01c3\3\2\2\2\u01c6") - buf.write("\u01c9\3\2\2\2\u01c7\u01c5\3\2\2\2\u01c7\u01c8\3\2\2\2") - buf.write("\u01c8\35\3\2\2\2\u01c9\u01c7\3\2\2\2\u01ca\u01cb\7\u00cf") - buf.write("\2\2\u01cb\u01d0\5V,\2\u01cc\u01cd\7\23\2\2\u01cd\u01cf") - buf.write("\5V,\2\u01ce\u01cc\3\2\2\2\u01cf\u01d2\3\2\2\2\u01d0\u01ce") - buf.write("\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\37\3\2\2\2\u01d2\u01d0") - buf.write("\3\2\2\2\u01d3\u01d4\t\t\2\2\u01d4\u01d5\7\3\2\2\u01d5") - buf.write("\u01d6\5\\/\2\u01d6\u01d7\5`\61\2\u01d7\u01d8\7\4\2\2") - buf.write("\u01d8\u01e0\3\2\2\2\u01d9\u01da\t\n\2\2\u01da\u01db\7") - buf.write("\3\2\2\u01db\u01dc\5Z.\2\u01dc\u01dd\5`\61\2\u01dd\u01de") - buf.write("\7\4\2\2\u01de\u01e0\3\2\2\2\u01df\u01d3\3\2\2\2\u01df") - buf.write("\u01d9\3\2\2\2\u01e0!\3\2\2\2\u01e1\u01e2\7}\2\2\u01e2") - buf.write("\u01e3\7|\2\2\u01e3\u01e4\5\u00d4k\2\u01e4\u01ed\7\3\2") - buf.write("\2\u01e5\u01ea\5t;\2\u01e6\u01e7\7\23\2\2\u01e7\u01e9") - buf.write("\5t;\2\u01e8\u01e6\3\2\2\2\u01e9\u01ec\3\2\2\2\u01ea\u01e8") - buf.write("\3\2\2\2\u01ea\u01eb\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec") - buf.write("\u01ea\3\2\2\2\u01ed\u01e5\3\2\2\2\u01ed\u01ee\3\2\2\2") - buf.write("\u01ee\u01ef\3\2\2\2\u01ef\u01f2\7\4\2\2\u01f0\u01f1\7") - buf.write("\u00cb\2\2\u01f1\u01f3\5v<\2\u01f2\u01f0\3\2\2\2\u01f2") - buf.write("\u01f3\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f5\7\u00ba") - buf.write("\2\2\u01f5\u01f6\5\6\4\2\u01f6\u01f7\7\u0083\2\2\u01f7") - buf.write("\u01f8\7|\2\2\u01f8\u0214\3\2\2\2\u01f9\u01fa\7}\2\2\u01fa") - buf.write("\u01fb\7\177\2\2\u01fb\u01fc\7\u0081\2\2\u01fc\u01fd\5") - buf.write("\u008eH\2\u01fd\u01fe\7\3\2\2\u01fe\u01ff\5\u0090I\2\u01ff") - buf.write("\u0200\7\4\2\2\u0200\u0201\7\u00ba\2\2\u0201\u0202\5\u0094") - buf.write("K\2\u0202\u0203\7\u0083\2\2\u0203\u0204\7\177\2\2\u0204") - buf.write("\u0205\7\u0081\2\2\u0205\u0214\3\2\2\2\u0206\u0207\7}") - buf.write("\2\2\u0207\u0208\7\u0080\2\2\u0208\u0209\7\u0081\2\2\u0209") - buf.write("\u020a\5\u008eH\2\u020a\u020b\7\3\2\2\u020b\u020c\5\u009c") - buf.write("O\2\u020c\u020d\7\4\2\2\u020d\u020e\7\u00ba\2\2\u020e") - buf.write("\u020f\5\u0098M\2\u020f\u0210\7\u0083\2\2\u0210\u0211") - buf.write("\7\u0080\2\2\u0211\u0212\7\u0081\2\2\u0212\u0214\3\2\2") - buf.write("\2\u0213\u01e1\3\2\2\2\u0213\u01f9\3\2\2\2\u0213\u0206") - buf.write("\3\2\2\2\u0214#\3\2\2\2\u0215\u0216\5\u00d4k\2\u0216\u021f") - buf.write("\7\3\2\2\u0217\u021c\5*\26\2\u0218\u0219\7\23\2\2\u0219") - buf.write("\u021b\5*\26\2\u021a\u0218\3\2\2\2\u021b\u021e\3\2\2\2") - buf.write("\u021c\u021a\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u0220\3") - buf.write("\2\2\2\u021e\u021c\3\2\2\2\u021f\u0217\3\2\2\2\u021f\u0220") - buf.write("\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0222\7\4\2\2\u0222") - buf.write("\u024f\3\2\2\2\u0223\u0224\7\30\2\2\u0224\u0225\7\3\2") - buf.write("\2\u0225\u0226\5\u00d6l\2\u0226\u0229\7\3\2\2\u0227\u022a") - buf.write("\5\u00bc_\2\u0228\u022a\5X-\2\u0229\u0227\3\2\2\2\u0229") - buf.write("\u0228\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u0232\3\2\2\2") - buf.write("\u022b\u022e\7\23\2\2\u022c\u022f\5\u00bc_\2\u022d\u022f") - buf.write("\5X-\2\u022e\u022c\3\2\2\2\u022e\u022d\3\2\2\2\u022f\u0231") - buf.write("\3\2\2\2\u0230\u022b\3\2\2\2\u0231\u0234\3\2\2\2\u0232") - buf.write("\u0230\3\2\2\2\u0232\u0233\3\2\2\2\u0233\u0235\3\2\2\2") - buf.write("\u0234\u0232\3\2\2\2\u0235\u0238\7\4\2\2\u0236\u0237\7") - buf.write("\u00f2\2\2\u0237\u0239\7\u00f6\2\2\u0238\u0236\3\2\2\2") - buf.write("\u0238\u0239\3\2\2\2\u0239\u023c\3\2\2\2\u023a\u023b\7") - buf.write("\u00cb\2\2\u023b\u023d\5\u0084C\2\u023c\u023a\3\2\2\2") - buf.write("\u023c\u023d\3\2\2\2\u023d\u023e\3\2\2\2\u023e\u023f\7") - buf.write("\4\2\2\u023f\u024f\3\2\2\2\u0240\u0241\7\u00dc\2\2\u0241") - buf.write("\u0242\7\3\2\2\u0242\u0243\5\6\4\2\u0243\u0246\7\23\2") - buf.write("\2\u0244\u0247\5\u00dan\2\u0245\u0247\5\u008cG\2\u0246") - buf.write("\u0244\3\2\2\2\u0246\u0245\3\2\2\2\u0247\u024a\3\2\2\2") - buf.write("\u0248\u0249\7\23\2\2\u0249\u024b\7\u00f6\2\2\u024a\u0248") - buf.write("\3\2\2\2\u024a\u024b\3\2\2\2\u024b\u024c\3\2\2\2\u024c") - buf.write("\u024d\7\4\2\2\u024d\u024f\3\2\2\2\u024e\u0215\3\2\2\2") - buf.write("\u024e\u0223\3\2\2\2\u024e\u0240\3\2\2\2\u024f%\3\2\2") - buf.write("\2\u0250\u0251\5\u00d4k\2\u0251\u025a\7\3\2\2\u0252\u0257") - buf.write("\5(\25\2\u0253\u0254\7\23\2\2\u0254\u0256\5(\25\2\u0255") - buf.write("\u0253\3\2\2\2\u0256\u0259\3\2\2\2\u0257\u0255\3\2\2\2") - buf.write("\u0257\u0258\3\2\2\2\u0258\u025b\3\2\2\2\u0259\u0257\3") - buf.write("\2\2\2\u025a\u0252\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c") - buf.write("\3\2\2\2\u025c\u025d\7\4\2\2\u025d\u028a\3\2\2\2\u025e") - buf.write("\u025f\7\u00dc\2\2\u025f\u0260\7\3\2\2\u0260\u0261\5\b") - buf.write("\5\2\u0261\u0264\7\23\2\2\u0262\u0265\5\u00dan\2\u0263") - buf.write("\u0265\5\u008cG\2\u0264\u0262\3\2\2\2\u0264\u0263\3\2") - buf.write("\2\2\u0265\u0268\3\2\2\2\u0266\u0267\7\23\2\2\u0267\u0269") - buf.write("\7\u00f6\2\2\u0268\u0266\3\2\2\2\u0268\u0269\3\2\2\2\u0269") - buf.write("\u026a\3\2\2\2\u026a\u026b\7\4\2\2\u026b\u028a\3\2\2\2") - buf.write("\u026c\u026d\7\30\2\2\u026d\u026e\7\3\2\2\u026e\u026f") - buf.write("\5\u00d6l\2\u026f\u0272\7\3\2\2\u0270\u0273\5\u00c0a\2") - buf.write("\u0271\u0273\5X-\2\u0272\u0270\3\2\2\2\u0272\u0271\3\2") - buf.write("\2\2\u0272\u0273\3\2\2\2\u0273\u027b\3\2\2\2\u0274\u0277") - buf.write("\7\23\2\2\u0275\u0278\5\u00c0a\2\u0276\u0278\5X-\2\u0277") - buf.write("\u0275\3\2\2\2\u0277\u0276\3\2\2\2\u0278\u027a\3\2\2\2") - buf.write("\u0279\u0274\3\2\2\2\u027a\u027d\3\2\2\2\u027b\u0279\3") - buf.write("\2\2\2\u027b\u027c\3\2\2\2\u027c\u027e\3\2\2\2\u027d\u027b") - buf.write("\3\2\2\2\u027e\u0281\7\4\2\2\u027f\u0280\7\u00f2\2\2\u0280") - buf.write("\u0282\7\u00f6\2\2\u0281\u027f\3\2\2\2\u0281\u0282\3\2") - buf.write("\2\2\u0282\u0285\3\2\2\2\u0283\u0284\7\u00cb\2\2\u0284") - buf.write("\u0286\5x=\2\u0285\u0283\3\2\2\2\u0285\u0286\3\2\2\2\u0286") - buf.write("\u0287\3\2\2\2\u0287\u0288\7\4\2\2\u0288\u028a\3\2\2\2") - buf.write("\u0289\u0250\3\2\2\2\u0289\u025e\3\2\2\2\u0289\u026c\3") - buf.write("\2\2\2\u028a'\3\2\2\2\u028b\u028e\5\b\5\2\u028c\u028e") - buf.write("\7u\2\2\u028d\u028b\3\2\2\2\u028d\u028c\3\2\2\2\u028e") - buf.write(")\3\2\2\2\u028f\u0292\5\6\4\2\u0290\u0292\7u\2\2\u0291") - buf.write("\u028f\3\2\2\2\u0291\u0290\3\2\2\2\u0292+\3\2\2\2\u0293") - buf.write("\u0294\t\13\2\2\u0294\u0295\7\3\2\2\u0295\u0296\5\6\4") - buf.write("\2\u0296\u0297\7\4\2\2\u0297\u02c4\3\2\2\2\u0298\u0299") - buf.write("\7d\2\2\u0299\u029a\7\3\2\2\u029a\u02a5\5\6\4\2\u029b") - buf.write("\u029c\7\23\2\2\u029c\u029d\5\u00caf\2\u029d\u029e\3\2") - buf.write("\2\2\u029e\u029f\7\23\2\2\u029f\u02a0\5\u00caf\2\u02a0") - buf.write("\u02a2\3\2\2\2\u02a1\u029b\3\2\2\2\u02a1\u02a2\3\2\2\2") - buf.write("\u02a2\u02a6\3\2\2\2\u02a3\u02a4\7\23\2\2\u02a4\u02a6") - buf.write("\5\u00caf\2\u02a5\u02a1\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a6") - buf.write("\u02a7\3\2\2\2\u02a7\u02a8\7\4\2\2\u02a8\u02c4\3\2\2\2") - buf.write("\u02a9\u02aa\7\u0088\2\2\u02aa\u02ab\7\3\2\2\u02ab\u02ac") - buf.write("\5\6\4\2\u02ac\u02ad\7\23\2\2\u02ad\u02b0\5\6\4\2\u02ae") - buf.write("\u02af\7\23\2\2\u02af\u02b1\5\u00caf\2\u02b0\u02ae\3\2") - buf.write("\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b3") - buf.write("\7\4\2\2\u02b3\u02c4\3\2\2\2\u02b4\u02b5\7\u0087\2\2\u02b5") - buf.write("\u02b6\7\3\2\2\u02b6\u02b7\5\6\4\2\u02b7\u02b8\7\23\2") - buf.write("\2\u02b8\u02bb\5\6\4\2\u02b9\u02ba\7\23\2\2\u02ba\u02bc") - buf.write("\5\u00caf\2\u02bb\u02b9\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc") - buf.write("\u02bf\3\2\2\2\u02bd\u02be\7\23\2\2\u02be\u02c0\5\u00ca") - buf.write("f\2\u02bf\u02bd\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0\u02c1") - buf.write("\3\2\2\2\u02c1\u02c2\7\4\2\2\u02c2\u02c4\3\2\2\2\u02c3") - buf.write("\u0293\3\2\2\2\u02c3\u0298\3\2\2\2\u02c3\u02a9\3\2\2\2") - buf.write("\u02c3\u02b4\3\2\2\2\u02c4-\3\2\2\2\u02c5\u02c6\t\13\2") - buf.write("\2\u02c6\u02c7\7\3\2\2\u02c7\u02c8\5\b\5\2\u02c8\u02c9") - buf.write("\7\4\2\2\u02c9\u02f6\3\2\2\2\u02ca\u02cb\7d\2\2\u02cb") - buf.write("\u02cc\7\3\2\2\u02cc\u02d7\5\b\5\2\u02cd\u02ce\7\23\2") - buf.write("\2\u02ce\u02cf\5\u00ccg\2\u02cf\u02d0\3\2\2\2\u02d0\u02d1") - buf.write("\7\23\2\2\u02d1\u02d2\5\u00ccg\2\u02d2\u02d4\3\2\2\2\u02d3") - buf.write("\u02cd\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4\u02d8\3\2\2\2") - buf.write("\u02d5\u02d6\7\23\2\2\u02d6\u02d8\5\u00ccg\2\u02d7\u02d3") - buf.write("\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d8\u02d9\3\2\2\2\u02d9") - buf.write("\u02da\7\4\2\2\u02da\u02f6\3\2\2\2\u02db\u02dc\7\u0088") - buf.write("\2\2\u02dc\u02dd\7\3\2\2\u02dd\u02de\5\b\5\2\u02de\u02df") - buf.write("\7\23\2\2\u02df\u02e2\5\b\5\2\u02e0\u02e1\7\23\2\2\u02e1") - buf.write("\u02e3\5\u00ccg\2\u02e2\u02e0\3\2\2\2\u02e2\u02e3\3\2") - buf.write("\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e5\7\4\2\2\u02e5\u02f6") - buf.write("\3\2\2\2\u02e6\u02e7\7\u0087\2\2\u02e7\u02e8\7\3\2\2\u02e8") - buf.write("\u02e9\5\b\5\2\u02e9\u02ea\7\23\2\2\u02ea\u02ed\5\b\5") - buf.write("\2\u02eb\u02ec\7\23\2\2\u02ec\u02ee\5\u00ccg\2\u02ed\u02eb") - buf.write("\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02f1\3\2\2\2\u02ef") - buf.write("\u02f0\7\23\2\2\u02f0\u02f2\5\u00ccg\2\u02f1\u02ef\3\2") - buf.write("\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f4") - buf.write("\7\4\2\2\u02f4\u02f6\3\2\2\2\u02f5\u02c5\3\2\2\2\u02f5") - buf.write("\u02ca\3\2\2\2\u02f5\u02db\3\2\2\2\u02f5\u02e6\3\2\2\2") - buf.write("\u02f6/\3\2\2\2\u02f7\u02f8\t\f\2\2\u02f8\u02f9\7\3\2") - buf.write("\2\u02f9\u02fa\5\6\4\2\u02fa\u02fb\7\4\2\2\u02fb\u030d") - buf.write("\3\2\2\2\u02fc\u02fd\t\r\2\2\u02fd\u02fe\7\3\2\2\u02fe") - buf.write("\u0301\5\6\4\2\u02ff\u0300\7\23\2\2\u0300\u0302\5\u00ca") - buf.write("f\2\u0301\u02ff\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0303") - buf.write("\3\2\2\2\u0303\u0304\7\4\2\2\u0304\u030d\3\2\2\2\u0305") - buf.write("\u0306\t\16\2\2\u0306\u0307\7\3\2\2\u0307\u0308\5\6\4") - buf.write("\2\u0308\u0309\7\23\2\2\u0309\u030a\5\6\4\2\u030a\u030b") - buf.write("\7\4\2\2\u030b\u030d\3\2\2\2\u030c\u02f7\3\2\2\2\u030c") - buf.write("\u02fc\3\2\2\2\u030c\u0305\3\2\2\2\u030d\61\3\2\2\2\u030e") - buf.write("\u030f\t\f\2\2\u030f\u0310\7\3\2\2\u0310\u0311\5\b\5\2") - buf.write("\u0311\u0312\7\4\2\2\u0312\u0324\3\2\2\2\u0313\u0314\t") - buf.write("\r\2\2\u0314\u0315\7\3\2\2\u0315\u0318\5\b\5\2\u0316\u0317") - buf.write("\7\23\2\2\u0317\u0319\5\u00ccg\2\u0318\u0316\3\2\2\2\u0318") - buf.write("\u0319\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u031b\7\4\2\2") - buf.write("\u031b\u0324\3\2\2\2\u031c\u031d\t\16\2\2\u031d\u031e") - buf.write("\7\3\2\2\u031e\u031f\5\b\5\2\u031f\u0320\7\23\2\2\u0320") - buf.write("\u0321\5\b\5\2\u0321\u0322\7\4\2\2\u0322\u0324\3\2\2\2") - buf.write("\u0323\u030e\3\2\2\2\u0323\u0313\3\2\2\2\u0323\u031c\3") - buf.write("\2\2\2\u0324\63\3\2\2\2\u0325\u0326\7\65\2\2\u0326\u0327") - buf.write("\7\3\2\2\u0327\u0328\5\6\4\2\u0328\u0329\7\23\2\2\u0329") - buf.write("\u032a\5\6\4\2\u032a\u032b\7\23\2\2\u032b\u032c\5\6\4") - buf.write("\2\u032c\u032d\7\4\2\2\u032d\u0346\3\2\2\2\u032e\u032f") - buf.write("\7q\2\2\u032f\u0330\7\3\2\2\u0330\u0331\5\6\4\2\u0331") - buf.write("\u0332\7\23\2\2\u0332\u0333\5\6\4\2\u0333\u0334\7\4\2") - buf.write("\2\u0334\u0346\3\2\2\2\u0335\u0336\79\2\2\u0336\u0337") - buf.write("\7\3\2\2\u0337\u0338\5\6\4\2\u0338\u0339\7\4\2\2\u0339") - buf.write("\u0346\3\2\2\2\u033a\u033b\7E\2\2\u033b\u033c\7\3\2\2") - buf.write("\u033c\u033d\5\6\4\2\u033d\u033e\7\23\2\2\u033e\u0341") - buf.write("\5\6\4\2\u033f\u0340\7\23\2\2\u0340\u0342\5\u00dco\2\u0341") - buf.write("\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0343\3\2\2\2") - buf.write("\u0343\u0344\7\4\2\2\u0344\u0346\3\2\2\2\u0345\u0325\3") - buf.write("\2\2\2\u0345\u032e\3\2\2\2\u0345\u0335\3\2\2\2\u0345\u033a") - buf.write("\3\2\2\2\u0346\65\3\2\2\2\u0347\u0348\7\65\2\2\u0348\u0349") - buf.write("\7\3\2\2\u0349\u034a\5\b\5\2\u034a\u034b\7\23\2\2\u034b") - buf.write("\u034c\5\b\5\2\u034c\u034d\7\23\2\2\u034d\u034e\5\b\5") - buf.write("\2\u034e\u034f\7\4\2\2\u034f\u035d\3\2\2\2\u0350\u0351") - buf.write("\7q\2\2\u0351\u0352\7\3\2\2\u0352\u0353\5\b\5\2\u0353") - buf.write("\u0354\7\23\2\2\u0354\u0355\5\b\5\2\u0355\u0356\7\4\2") - buf.write("\2\u0356\u035d\3\2\2\2\u0357\u0358\79\2\2\u0358\u0359") - buf.write("\7\3\2\2\u0359\u035a\5\b\5\2\u035a\u035b\7\4\2\2\u035b") - buf.write("\u035d\3\2\2\2\u035c\u0347\3\2\2\2\u035c\u0350\3\2\2\2") - buf.write("\u035c\u0357\3\2\2\2\u035d\67\3\2\2\2\u035e\u035f\7\u00d2") - buf.write("\2\2\u035f\u0361\7\3\2\2\u0360\u0362\5\6\4\2\u0361\u0360") - buf.write("\3\2\2\2\u0361\u0362\3\2\2\2\u0362\u0363\3\2\2\2\u0363") - buf.write("\u03c5\7\4\2\2\u0364\u0365\7\u00a3\2\2\u0365\u0366\7\3") - buf.write("\2\2\u0366\u0369\5\6\4\2\u0367\u0368\7\23\2\2\u0368\u036a") - buf.write("\t\17\2\2\u0369\u0367\3\2\2\2\u0369\u036a\3\2\2\2\u036a") - buf.write("\u036b\3\2\2\2\u036b\u036c\7\4\2\2\u036c\u03c5\3\2\2\2") - buf.write("\u036d\u036e\t\20\2\2\u036e\u036f\7\3\2\2\u036f\u0370") - buf.write("\5\6\4\2\u0370\u0371\7\4\2\2\u0371\u03c5\3\2\2\2\u0372") - buf.write("\u0373\7\u00a6\2\2\u0373\u0374\7\3\2\2\u0374\u0375\5\6") - buf.write("\4\2\u0375\u0376\7\23\2\2\u0376\u0377\5l\67\2\u0377\u0378") - buf.write("\7\4\2\2\u0378\u03c5\3\2\2\2\u0379\u037a\7\u00d5\2\2\u037a") - buf.write("\u037b\7\3\2\2\u037b\u037e\7\u00f6\2\2\u037c\u037d\7\23") - buf.write("\2\2\u037d\u037f\t\21\2\2\u037e\u037c\3\2\2\2\u037e\u037f") - buf.write("\3\2\2\2\u037f\u0382\3\2\2\2\u0380\u0381\7\23\2\2\u0381") - buf.write("\u0383\5\u00caf\2\u0382\u0380\3\2\2\2\u0382\u0383\3\2") - buf.write("\2\2\u0383\u0386\3\2\2\2\u0384\u0385\7\23\2\2\u0385\u0387") - buf.write("\t\22\2\2\u0386\u0384\3\2\2\2\u0386\u0387\3\2\2\2\u0387") - buf.write("\u0388\3\2\2\2\u0388\u03c5\7\4\2\2\u0389\u038a\7\37\2") - buf.write("\2\u038a\u038b\7\3\2\2\u038b\u03c5\7\4\2\2\u038c\u038d") - buf.write("\7 \2\2\u038d\u038e\7\3\2\2\u038e\u038f\5\6\4\2\u038f") - buf.write("\u0390\7\23\2\2\u0390\u0391\5\6\4\2\u0391\u0392\7\4\2") - buf.write("\2\u0392\u03c5\3\2\2\2\u0393\u0394\7!\2\2\u0394\u0395") - buf.write("\7\3\2\2\u0395\u0396\5\6\4\2\u0396\u0397\7\23\2\2\u0397") - buf.write("\u0398\5\6\4\2\u0398\u0399\7\23\2\2\u0399\u039a\5\6\4") - buf.write("\2\u039a\u039b\7\4\2\2\u039b\u03c5\3\2\2\2\u039c\u039d") - buf.write('\7"\2\2\u039d\u039e\7\3\2\2\u039e\u039f\5\6\4\2\u039f') - buf.write("\u03a0\7\4\2\2\u03a0\u03c5\3\2\2\2\u03a1\u03a2\7#\2\2") - buf.write("\u03a2\u03a3\7\3\2\2\u03a3\u03a4\5\6\4\2\u03a4\u03a5\7") - buf.write("\4\2\2\u03a5\u03c5\3\2\2\2\u03a6\u03a7\7$\2\2\u03a7\u03a8") - buf.write("\7\3\2\2\u03a8\u03a9\5\6\4\2\u03a9\u03aa\7\4\2\2\u03aa") - buf.write("\u03c5\3\2\2\2\u03ab\u03ac\7%\2\2\u03ac\u03ad\7\3\2\2") - buf.write("\u03ad\u03ae\5\6\4\2\u03ae\u03af\7\4\2\2\u03af\u03c5\3") - buf.write("\2\2\2\u03b0\u03b1\7&\2\2\u03b1\u03b2\7\3\2\2\u03b2\u03b3") - buf.write("\5\6\4\2\u03b3\u03b4\7\4\2\2\u03b4\u03c5\3\2\2\2\u03b5") - buf.write("\u03b6\7'\2\2\u03b6\u03b7\7\3\2\2\u03b7\u03b8\5\6\4\2") - buf.write("\u03b8\u03b9\7\4\2\2\u03b9\u03c5\3\2\2\2\u03ba\u03bb\7") - buf.write("(\2\2\u03bb\u03bc\7\3\2\2\u03bc\u03bd\5\6\4\2\u03bd\u03be") - buf.write("\7\4\2\2\u03be\u03c5\3\2\2\2\u03bf\u03c0\7)\2\2\u03c0") - buf.write("\u03c1\7\3\2\2\u03c1\u03c2\5\6\4\2\u03c2\u03c3\7\4\2\2") - buf.write("\u03c3\u03c5\3\2\2\2\u03c4\u035e\3\2\2\2\u03c4\u0364\3") - buf.write("\2\2\2\u03c4\u036d\3\2\2\2\u03c4\u0372\3\2\2\2\u03c4\u0379") - buf.write("\3\2\2\2\u03c4\u0389\3\2\2\2\u03c4\u038c\3\2\2\2\u03c4") - buf.write("\u0393\3\2\2\2\u03c4\u039c\3\2\2\2\u03c4\u03a1\3\2\2\2") - buf.write("\u03c4\u03a6\3\2\2\2\u03c4\u03ab\3\2\2\2\u03c4\u03b0\3") - buf.write("\2\2\2\u03c4\u03b5\3\2\2\2\u03c4\u03ba\3\2\2\2\u03c4\u03bf") - buf.write("\3\2\2\2\u03c59\3\2\2\2\u03c6\u03c7\7\u00d2\2\2\u03c7") - buf.write("\u03c9\7\3\2\2\u03c8\u03ca\5\b\5\2\u03c9\u03c8\3\2\2\2") - buf.write("\u03c9\u03ca\3\2\2\2\u03ca\u03cb\3\2\2\2\u03cb\u042d\7") - buf.write("\4\2\2\u03cc\u03cd\7\u00a3\2\2\u03cd\u03ce\7\3\2\2\u03ce") - buf.write("\u03d1\5\b\5\2\u03cf\u03d0\7\23\2\2\u03d0\u03d2\t\17\2") - buf.write("\2\u03d1\u03cf\3\2\2\2\u03d1\u03d2\3\2\2\2\u03d2\u03d3") - buf.write("\3\2\2\2\u03d3\u03d4\7\4\2\2\u03d4\u042d\3\2\2\2\u03d5") - buf.write("\u03d6\t\20\2\2\u03d6\u03d7\7\3\2\2\u03d7\u03d8\5\b\5") - buf.write("\2\u03d8\u03d9\7\4\2\2\u03d9\u042d\3\2\2\2\u03da\u03db") - buf.write("\7\u00a6\2\2\u03db\u03dc\7\3\2\2\u03dc\u03dd\5\b\5\2\u03dd") - buf.write("\u03de\7\23\2\2\u03de\u03df\5l\67\2\u03df\u03e0\7\4\2") - buf.write("\2\u03e0\u042d\3\2\2\2\u03e1\u03e2\7\u00d5\2\2\u03e2\u03e3") - buf.write("\7\3\2\2\u03e3\u03e6\7\u00f6\2\2\u03e4\u03e5\7\23\2\2") - buf.write("\u03e5\u03e7\t\21\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e7") - buf.write("\3\2\2\2\u03e7\u03ea\3\2\2\2\u03e8\u03e9\7\23\2\2\u03e9") - buf.write("\u03eb\5\u00ccg\2\u03ea\u03e8\3\2\2\2\u03ea\u03eb\3\2") - buf.write("\2\2\u03eb\u03ee\3\2\2\2\u03ec\u03ed\7\23\2\2\u03ed\u03ef") - buf.write("\t\22\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef") - buf.write("\u03f0\3\2\2\2\u03f0\u042d\7\4\2\2\u03f1\u03f2\7\37\2") - buf.write("\2\u03f2\u03f3\7\3\2\2\u03f3\u042d\7\4\2\2\u03f4\u03f5") - buf.write("\7 \2\2\u03f5\u03f6\7\3\2\2\u03f6\u03f7\5\b\5\2\u03f7") - buf.write("\u03f8\7\23\2\2\u03f8\u03f9\5\b\5\2\u03f9\u03fa\7\4\2") - buf.write("\2\u03fa\u042d\3\2\2\2\u03fb\u03fc\7!\2\2\u03fc\u03fd") - buf.write("\7\3\2\2\u03fd\u03fe\5\b\5\2\u03fe\u03ff\7\23\2\2\u03ff") - buf.write("\u0400\5\b\5\2\u0400\u0401\7\23\2\2\u0401\u0402\5\b\5") - buf.write("\2\u0402\u0403\7\4\2\2\u0403\u042d\3\2\2\2\u0404\u0405") - buf.write('\7"\2\2\u0405\u0406\7\3\2\2\u0406\u0407\5\b\5\2\u0407') - buf.write("\u0408\7\4\2\2\u0408\u042d\3\2\2\2\u0409\u040a\7#\2\2") - buf.write("\u040a\u040b\7\3\2\2\u040b\u040c\5\b\5\2\u040c\u040d\7") - buf.write("\4\2\2\u040d\u042d\3\2\2\2\u040e\u040f\7$\2\2\u040f\u0410") - buf.write("\7\3\2\2\u0410\u0411\5\b\5\2\u0411\u0412\7\4\2\2\u0412") - buf.write("\u042d\3\2\2\2\u0413\u0414\7%\2\2\u0414\u0415\7\3\2\2") - buf.write("\u0415\u0416\5\b\5\2\u0416\u0417\7\4\2\2\u0417\u042d\3") - buf.write("\2\2\2\u0418\u0419\7&\2\2\u0419\u041a\7\3\2\2\u041a\u041b") - buf.write("\5\b\5\2\u041b\u041c\7\4\2\2\u041c\u042d\3\2\2\2\u041d") - buf.write("\u041e\7'\2\2\u041e\u041f\7\3\2\2\u041f\u0420\5\b\5\2") - buf.write("\u0420\u0421\7\4\2\2\u0421\u042d\3\2\2\2\u0422\u0423\7") - buf.write("(\2\2\u0423\u0424\7\3\2\2\u0424\u0425\5\b\5\2\u0425\u0426") - buf.write("\7\4\2\2\u0426\u042d\3\2\2\2\u0427\u0428\7)\2\2\u0428") - buf.write("\u0429\7\3\2\2\u0429\u042a\5\b\5\2\u042a\u042b\7\4\2\2") - buf.write("\u042b\u042d\3\2\2\2\u042c\u03c6\3\2\2\2\u042c\u03cc\3") - buf.write("\2\2\2\u042c\u03d5\3\2\2\2\u042c\u03da\3\2\2\2\u042c\u03e1") - buf.write("\3\2\2\2\u042c\u03f1\3\2\2\2\u042c\u03f4\3\2\2\2\u042c") - buf.write("\u03fb\3\2\2\2\u042c\u0404\3\2\2\2\u042c\u0409\3\2\2\2") - buf.write("\u042c\u040e\3\2\2\2\u042c\u0413\3\2\2\2\u042c\u0418\3") - buf.write("\2\2\2\u042c\u041d\3\2\2\2\u042c\u0422\3\2\2\2\u042c\u0427") - buf.write("\3\2\2\2\u042d;\3\2\2\2\u042e\u042f\7;\2\2\u042f\u0430") - buf.write("\7\3\2\2\u0430\u0433\5\6\4\2\u0431\u0432\7\23\2\2\u0432") - buf.write("\u0434\5\6\4\2\u0433\u0431\3\2\2\2\u0434\u0435\3\2\2\2") - buf.write("\u0435\u0433\3\2\2\2\u0435\u0436\3\2\2\2\u0436\u0437\3") - buf.write("\2\2\2\u0437\u0438\7\4\2\2\u0438\u044c\3\2\2\2\u0439\u043a") - buf.write("\7>\2\2\u043a\u043b\7\3\2\2\u043b\u043e\5\6\4\2\u043c") - buf.write("\u043d\7\23\2\2\u043d\u043f\5\6\4\2\u043e\u043c\3\2\2") - buf.write("\2\u043f\u0440\3\2\2\2\u0440\u043e\3\2\2\2\u0440\u0441") - buf.write("\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0443\7\4\2\2\u0443") - buf.write("\u044c\3\2\2\2\u0444\u0445\t\23\2\2\u0445\u0446\7\3\2") - buf.write("\2\u0446\u0447\5\6\4\2\u0447\u0448\7\23\2\2\u0448\u0449") - buf.write("\5\6\4\2\u0449\u044a\7\4\2\2\u044a\u044c\3\2\2\2\u044b") - buf.write("\u042e\3\2\2\2\u044b\u0439\3\2\2\2\u044b\u0444\3\2\2\2") - buf.write("\u044c=\3\2\2\2\u044d\u044e\7t\2\2\u044e\u044f\7\3\2\2") - buf.write("\u044f\u0450\5\6\4\2\u0450\u0451\7\23\2\2\u0451\u0453") - buf.write("\7\u00f7\2\2\u0452\u0454\5\u00b0Y\2\u0453\u0452\3\2\2") - buf.write("\2\u0453\u0454\3\2\2\2\u0454\u0457\3\2\2\2\u0455\u0456") - buf.write("\7\u0082\2\2\u0456\u0458\5\u00c0a\2\u0457\u0455\3\2\2") - buf.write("\2\u0457\u0458\3\2\2\2\u0458\u045a\3\2\2\2\u0459\u045b") - buf.write("\5\u00aeX\2\u045a\u0459\3\2\2\2\u045a\u045b\3\2\2\2\u045b") - buf.write("\u045d\3\2\2\2\u045c\u045e\5\u00b6\\\2\u045d\u045c\3\2") - buf.write("\2\2\u045d\u045e\3\2\2\2\u045e\u0460\3\2\2\2\u045f\u0461") - buf.write("\5\u00b8]\2\u0460\u045f\3\2\2\2\u0460\u0461\3\2\2\2\u0461") - buf.write("\u0462\3\2\2\2\u0462\u0463\7\4\2\2\u0463?\3\2\2\2\u0464") - buf.write("\u0465\7\u00e0\2\2\u0465\u0466\7\3\2\2\u0466\u0467\5\6") - buf.write("\4\2\u0467\u0468\7\23\2\2\u0468\u0472\7\u00f7\2\2\u0469") - buf.write("\u046a\7\u00e9\2\2\u046a\u046f\5\u00c0a\2\u046b\u046c") - buf.write("\7\23\2\2\u046c\u046e\5\u00c0a\2\u046d\u046b\3\2\2\2\u046e") - buf.write("\u0471\3\2\2\2\u046f\u046d\3\2\2\2\u046f\u0470\3\2\2\2") - buf.write("\u0470\u0473\3\2\2\2\u0471\u046f\3\2\2\2\u0472\u0469\3") - buf.write("\2\2\2\u0472\u0473\3\2\2\2\u0473\u0475\3\2\2\2\u0474\u0476") - buf.write("\5\u00acW\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476") + buf.write(",\3-\3-\3-\3-\3-\3-\3-\3-\5-\u055c\n-\3-\3-\3-\3-\3-\3") + buf.write("-\3-\3-\3-\5-\u0567\n-\3-\3-\5-\u056b\n-\3.\3.\3.\7.\u0570") + buf.write("\n.\f.\16.\u0573\13.\3/\3/\3/\7/\u0578\n/\f/\16/\u057b") + buf.write("\13/\3/\3/\3/\3/\7/\u0581\n/\f/\16/\u0584\13/\5/\u0586") + buf.write("\n/\3\60\3\60\3\60\5\60\u058b\n\60\3\61\5\61\u058e\n\61") + buf.write("\3\61\3\61\3\61\5\61\u0593\n\61\3\61\5\61\u0596\n\61\3") + buf.write("\61\5\61\u0599\n\61\3\62\3\62\3\62\3\63\3\63\3\63\3\63") + buf.write("\3\63\7\63\u05a3\n\63\f\63\16\63\u05a6\13\63\3\64\3\64") + buf.write("\3\64\3\64\3\64\7\64\u05ad\n\64\f\64\16\64\u05b0\13\64") + buf.write("\3\65\3\65\5\65\u05b4\n\65\3\66\3\66\3\66\5\66\u05b9\n") + buf.write("\66\3\66\3\66\3\66\3\66\3\66\3\67\3\67\38\38\38\38\38") + buf.write("\38\38\38\38\38\38\58\u05cd\n8\39\39\39\39\39\79\u05d4") + buf.write("\n9\f9\169\u05d7\139\39\39\39\59\u05dc\n9\3:\3:\3:\3;") + buf.write("\3;\3;\3;\5;\u05e5\n;\3<\3<\3<\5<\u05ea\n<\3=\3=\5=\u05ee") + buf.write("\n=\3>\3>\3>\3>\3>\5>\u05f5\n>\3?\3?\3?\5?\u05fa\n?\3") + buf.write("@\3@\5@\u05fe\n@\3@\5@\u0601\n@\3@\5@\u0604\n@\3@\5@\u0607") + buf.write("\n@\3A\3A\3A\3A\3A\5A\u060e\nA\3B\3B\3B\3B\3B\7B\u0615") + buf.write("\nB\fB\16B\u0618\13B\3B\3B\5B\u061c\nB\3C\3C\5C\u0620") + buf.write("\nC\3D\3D\3D\3D\3D\5D\u0627\nD\3E\3E\3E\3E\3E\3E\7E\u062f") + buf.write("\nE\fE\16E\u0632\13E\3E\3E\5E\u0636\nE\3E\3E\3E\3E\3E") + buf.write("\7E\u063d\nE\fE\16E\u0640\13E\3E\3E\5E\u0644\nE\5E\u0646") + buf.write("\nE\3F\3F\3F\3F\3F\3F\3F\3F\7F\u0650\nF\fF\16F\u0653\13") + buf.write("F\3F\3F\5F\u0657\nF\3F\5F\u065a\nF\3F\3F\3F\3F\3F\3F\3") + buf.write("F\7F\u0663\nF\fF\16F\u0666\13F\3F\3F\5F\u066a\nF\3F\3") + buf.write("F\5F\u066e\nF\5F\u0670\nF\3G\3G\3H\3H\3I\3I\3I\3I\7I\u067a") + buf.write("\nI\fI\16I\u067d\13I\3J\3J\3J\5J\u0682\nJ\3K\3K\3K\7K") + buf.write("\u0687\nK\fK\16K\u068a\13K\3L\3L\5L\u068e\nL\3L\3L\3L") + buf.write("\3L\5L\u0694\nL\3L\3L\5L\u0698\nL\3L\5L\u069b\nL\3M\3") + buf.write("M\3M\7M\u06a0\nM\fM\16M\u06a3\13M\3N\3N\5N\u06a7\nN\3") + buf.write("N\3N\5N\u06ab\nN\3N\5N\u06ae\nN\3O\3O\3O\5O\u06b3\nO\3") + buf.write("O\3O\3O\3P\3P\3P\7P\u06bb\nP\fP\16P\u06be\13P\3Q\3Q\3") + buf.write("Q\3Q\5Q\u06c4\nQ\3Q\3Q\5Q\u06c8\nQ\3Q\3Q\7Q\u06cc\nQ\f") + buf.write("Q\16Q\u06cf\13Q\3R\5R\u06d2\nR\3R\3R\3R\3R\3R\5R\u06d9") + buf.write("\nR\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\7T\u06e5\nT\fT\16T\u06e8") + buf.write("\13T\3T\3T\5T\u06ec\nT\3U\3U\3U\5U\u06f1\nU\3V\3V\5V\u06f5") + buf.write("\nV\3W\3W\3X\3X\3Y\3Y\3Y\3Y\7Y\u06ff\nY\fY\16Y\u0702\13") + buf.write("Y\3Z\3Z\3[\3[\3[\3\\\3\\\3]\3]\3^\3^\3_\3_\3`\3`\3a\3") + buf.write("a\3a\5a\u0716\na\3b\3b\3b\3b\7b\u071c\nb\fb\16b\u071f") + buf.write("\13b\3b\3b\3c\3c\3c\3d\3d\3d\3e\3e\3f\3f\5f\u072d\nf\3") + buf.write("g\3g\5g\u0731\ng\3h\3h\3h\3h\3h\5h\u0738\nh\3i\3i\3i\3") + buf.write("j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3o\2\4\6\bp\2\4\6\b") + buf.write('\n\f\16\20\22\24\26\30\32\34\36 "$&(*,.\60\62\64\668') + buf.write(":<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084") + buf.write("\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096") + buf.write("\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8") + buf.write("\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba") + buf.write("\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc") + buf.write("\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\2'\4") + buf.write("\2\17\20\64\64\3\2\21\22\4\2\17\20``\3\2\62\63\3\2\66") + buf.write("\67\3\2+,\4\2\u00cc\u00cc\u00ce\u00ce\3\2\u00c3\u00c4") + buf.write("\3\2\u00c5\u00c6\5\2__ac\u0085\u0086\6\2WWYYnn\u0089\u008b") + buf.write("\3\2[\\\5\2??ZZ]^\4\2JJ\u00d3\u00d3\3\2\u00a4\u00a5\4") + buf.write("\2uu\u00f6\u00f6\3\2TU\4\2==\u008d\u008d\4\2JJvv\5\2R") + buf.write("Seh\u008e\u0091\6\2RSeh\u008e\u0091\u0095\u0096\3\2\u0097") + buf.write("\u0098\3\2PQ\4\2NN\u0093\u0093\3\2wx\3\2\17\20\4\2\u00f3") + buf.write("\u00f4\u00f7\u00f7\4\2\17\17\21\21\5\2JJvv\u00ea\u00ea") + buf.write("\3\2\u00e3\u00e8\4\2{{\u00de\u00de\5\2{{\u0082\u0082\u00dd") + buf.write("\u00dd\4\2JJ\u00e2\u00e2\3\2\t\16\4\288\u00f3\u00f6\5") + buf.write("\2\u00aa\u00b0\u00d4\u00d4\u00eb\u00eb\4\2JJ\u00f5\u00f5") + buf.write("\2\u0807\2\u00e3\3\2\2\2\4\u00f1\3\2\2\2\6\u0111\3\2\2") + buf.write("\2\b\u0154\3\2\2\2\n\u0179\3\2\2\2\f\u0187\3\2\2\2\16") + buf.write("\u0190\3\2\2\2\20\u0192\3\2\2\2\22\u019b\3\2\2\2\24\u01a3") + buf.write("\3\2\2\2\26\u01a6\3\2\2\2\30\u01af\3\2\2\2\32\u01b8\3") + buf.write("\2\2\2\34\u01bd\3\2\2\2\36\u01ca\3\2\2\2 \u01df\3\2\2") + buf.write('\2"\u0213\3\2\2\2$\u024e\3\2\2\2&\u0289\3\2\2\2(\u028d') + buf.write("\3\2\2\2*\u0291\3\2\2\2,\u02c3\3\2\2\2.\u02f5\3\2\2\2") + buf.write("\60\u030c\3\2\2\2\62\u0323\3\2\2\2\64\u0345\3\2\2\2\66") + buf.write("\u035c\3\2\2\28\u03c4\3\2\2\2:\u042c\3\2\2\2<\u044b\3") + buf.write("\2\2\2>\u044d\3\2\2\2@\u04a1\3\2\2\2B\u04a3\3\2\2\2D\u04aa") + buf.write("\3\2\2\2F\u04b9\3\2\2\2H\u04bb\3\2\2\2J\u04f5\3\2\2\2") + buf.write("L\u0531\3\2\2\2N\u0533\3\2\2\2P\u0537\3\2\2\2R\u0540\3") + buf.write("\2\2\2T\u0547\3\2\2\2V\u054d\3\2\2\2X\u056a\3\2\2\2Z\u056c") + buf.write("\3\2\2\2\\\u0574\3\2\2\2^\u0587\3\2\2\2`\u058d\3\2\2\2") + buf.write("b\u059a\3\2\2\2d\u059d\3\2\2\2f\u05a7\3\2\2\2h\u05b1\3") + buf.write("\2\2\2j\u05b8\3\2\2\2l\u05bf\3\2\2\2n\u05cc\3\2\2\2p\u05db") + buf.write("\3\2\2\2r\u05dd\3\2\2\2t\u05e0\3\2\2\2v\u05e9\3\2\2\2") + buf.write("x\u05ed\3\2\2\2z\u05f4\3\2\2\2|\u05f9\3\2\2\2~\u05fd\3") + buf.write("\2\2\2\u0080\u0608\3\2\2\2\u0082\u060f\3\2\2\2\u0084\u061f") + buf.write("\3\2\2\2\u0086\u0621\3\2\2\2\u0088\u0645\3\2\2\2\u008a") + buf.write("\u066f\3\2\2\2\u008c\u0671\3\2\2\2\u008e\u0673\3\2\2\2") + buf.write("\u0090\u0675\3\2\2\2\u0092\u067e\3\2\2\2\u0094\u0683\3") + buf.write("\2\2\2\u0096\u068d\3\2\2\2\u0098\u069c\3\2\2\2\u009a\u06a6") + buf.write("\3\2\2\2\u009c\u06af\3\2\2\2\u009e\u06b7\3\2\2\2\u00a0") + buf.write("\u06c3\3\2\2\2\u00a2\u06d1\3\2\2\2\u00a4\u06da\3\2\2\2") + buf.write("\u00a6\u06eb\3\2\2\2\u00a8\u06ed\3\2\2\2\u00aa\u06f2\3") + buf.write("\2\2\2\u00ac\u06f6\3\2\2\2\u00ae\u06f8\3\2\2\2\u00b0\u06fa") + buf.write("\3\2\2\2\u00b2\u0703\3\2\2\2\u00b4\u0705\3\2\2\2\u00b6") + buf.write("\u0708\3\2\2\2\u00b8\u070a\3\2\2\2\u00ba\u070c\3\2\2\2") + buf.write("\u00bc\u070e\3\2\2\2\u00be\u0710\3\2\2\2\u00c0\u0712\3") + buf.write("\2\2\2\u00c2\u0717\3\2\2\2\u00c4\u0722\3\2\2\2\u00c6\u0725") + buf.write("\3\2\2\2\u00c8\u0728\3\2\2\2\u00ca\u072c\3\2\2\2\u00cc") + buf.write("\u0730\3\2\2\2\u00ce\u0737\3\2\2\2\u00d0\u0739\3\2\2\2") + buf.write("\u00d2\u073c\3\2\2\2\u00d4\u073e\3\2\2\2\u00d6\u0740\3") + buf.write("\2\2\2\u00d8\u0742\3\2\2\2\u00da\u0744\3\2\2\2\u00dc\u0746") + buf.write("\3\2\2\2\u00de\u00df\5\4\3\2\u00df\u00e0\7\u00f9\2\2\u00e0") + buf.write("\u00e2\3\2\2\2\u00e1\u00de\3\2\2\2\u00e2\u00e5\3\2\2\2") + buf.write("\u00e3\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00e6\3") + buf.write("\2\2\2\u00e5\u00e3\3\2\2\2\u00e6\u00e7\7\2\2\3\u00e7\3") + buf.write("\3\2\2\2\u00e8\u00e9\5\u00bc_\2\u00e9\u00ea\7\26\2\2\u00ea") + buf.write("\u00eb\5\6\4\2\u00eb\u00f2\3\2\2\2\u00ec\u00ed\5\u00bc") + buf.write("_\2\u00ed\u00ee\7~\2\2\u00ee\u00ef\5\6\4\2\u00ef\u00f2") + buf.write('\3\2\2\2\u00f0\u00f2\5"\22\2\u00f1\u00e8\3\2\2\2\u00f1') + buf.write("\u00ec\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\5\3\2\2\2\u00f3") + buf.write("\u00f4\b\4\1\2\u00f4\u00f5\7\3\2\2\u00f5\u00f6\5\6\4\2") + buf.write("\u00f6\u00f7\7\4\2\2\u00f7\u0112\3\2\2\2\u00f8\u0112\5") + buf.write("\f\7\2\u00f9\u00fa\t\2\2\2\u00fa\u0112\5\6\4\r\u00fb\u00fc") + buf.write("\7\31\2\2\u00fc\u00fd\5\6\4\2\u00fd\u00fe\7\33\2\2\u00fe") + buf.write("\u00ff\5\6\4\2\u00ff\u0100\7\34\2\2\u0100\u0101\5\6\4") + buf.write("\6\u0101\u0112\3\2\2\2\u0102\u0108\7\32\2\2\u0103\u0104") + buf.write("\7\u00bb\2\2\u0104\u0105\5\6\4\2\u0105\u0106\7\33\2\2") + buf.write("\u0106\u0107\5\6\4\2\u0107\u0109\3\2\2\2\u0108\u0103\3") + buf.write("\2\2\2\u0109\u010a\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b") + buf.write("\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u010d\7\34\2\2\u010d") + buf.write("\u010e\5\6\4\5\u010e\u0112\3\2\2\2\u010f\u0112\5\u00d8") + buf.write("m\2\u0110\u0112\5\u00bc_\2\u0111\u00f3\3\2\2\2\u0111\u00f8") + buf.write("\3\2\2\2\u0111\u00f9\3\2\2\2\u0111\u00fb\3\2\2\2\u0111") + buf.write("\u0102\3\2\2\2\u0111\u010f\3\2\2\2\u0111\u0110\3\2\2\2") + buf.write("\u0112\u0133\3\2\2\2\u0113\u0114\f\f\2\2\u0114\u0115\t") + buf.write("\3\2\2\u0115\u0132\5\6\4\r\u0116\u0117\f\13\2\2\u0117") + buf.write("\u0118\t\4\2\2\u0118\u0132\5\6\4\f\u0119\u011a\f\n\2\2") + buf.write("\u011a\u011b\5\u00c8e\2\u011b\u011c\5\6\4\13\u011c\u0132") + buf.write("\3\2\2\2\u011d\u011e\f\b\2\2\u011e\u011f\7\61\2\2\u011f") + buf.write("\u0132\5\6\4\t\u0120\u0121\f\7\2\2\u0121\u0122\t\5\2\2") + buf.write("\u0122\u0132\5\6\4\b\u0123\u0124\f\17\2\2\u0124\u0125") + buf.write("\7\5\2\2\u0125\u0126\5\16\b\2\u0126\u0127\7\6\2\2\u0127") + buf.write("\u0132\3\2\2\2\u0128\u0129\f\16\2\2\u0129\u012a\7\27\2") + buf.write("\2\u012a\u0132\5\u00be`\2\u012b\u012c\f\t\2\2\u012c\u012f") + buf.write("\t\6\2\2\u012d\u0130\5\u00c2b\2\u012e\u0130\5\u00d2j\2") + buf.write("\u012f\u012d\3\2\2\2\u012f\u012e\3\2\2\2\u0130\u0132\3") + buf.write("\2\2\2\u0131\u0113\3\2\2\2\u0131\u0116\3\2\2\2\u0131\u0119") + buf.write("\3\2\2\2\u0131\u011d\3\2\2\2\u0131\u0120\3\2\2\2\u0131") + buf.write("\u0123\3\2\2\2\u0131\u0128\3\2\2\2\u0131\u012b\3\2\2\2") + buf.write("\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0134\3") + buf.write("\2\2\2\u0134\7\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u0137") + buf.write("\b\5\1\2\u0137\u0138\7\3\2\2\u0138\u0139\5\b\5\2\u0139") + buf.write("\u013a\7\4\2\2\u013a\u0155\3\2\2\2\u013b\u0155\5\n\6\2") + buf.write("\u013c\u013d\t\2\2\2\u013d\u0155\5\b\5\r\u013e\u013f\7") + buf.write("\31\2\2\u013f\u0140\5\b\5\2\u0140\u0141\7\33\2\2\u0141") + buf.write("\u0142\5\b\5\2\u0142\u0143\7\34\2\2\u0143\u0144\5\b\5") + buf.write("\6\u0144\u0155\3\2\2\2\u0145\u014b\7\32\2\2\u0146\u0147") + buf.write("\7\u00bb\2\2\u0147\u0148\5\b\5\2\u0148\u0149\7\33\2\2") + buf.write("\u0149\u014a\5\b\5\2\u014a\u014c\3\2\2\2\u014b\u0146\3") + buf.write("\2\2\2\u014c\u014d\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e") + buf.write("\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0150\7\34\2\2\u0150") + buf.write("\u0151\5\b\5\5\u0151\u0155\3\2\2\2\u0152\u0155\5\u00d8") + buf.write("m\2\u0153\u0155\5\u00c0a\2\u0154\u0136\3\2\2\2\u0154\u013b") + buf.write("\3\2\2\2\u0154\u013c\3\2\2\2\u0154\u013e\3\2\2\2\u0154") + buf.write("\u0145\3\2\2\2\u0154\u0152\3\2\2\2\u0154\u0153\3\2\2\2") + buf.write("\u0155\u016e\3\2\2\2\u0156\u0157\f\f\2\2\u0157\u0158\t") + buf.write("\3\2\2\u0158\u016d\5\b\5\r\u0159\u015a\f\13\2\2\u015a") + buf.write("\u015b\t\4\2\2\u015b\u016d\5\b\5\f\u015c\u015d\f\n\2\2") + buf.write("\u015d\u015e\5\u00c8e\2\u015e\u015f\5\b\5\13\u015f\u016d") + buf.write("\3\2\2\2\u0160\u0161\f\b\2\2\u0161\u0162\7\61\2\2\u0162") + buf.write("\u016d\5\b\5\t\u0163\u0164\f\7\2\2\u0164\u0165\t\5\2\2") + buf.write("\u0165\u016d\5\b\5\b\u0166\u0167\f\t\2\2\u0167\u016a\t") + buf.write("\6\2\2\u0168\u016b\5\u00c2b\2\u0169\u016b\5\u00d2j\2\u016a") + buf.write("\u0168\3\2\2\2\u016a\u0169\3\2\2\2\u016b\u016d\3\2\2\2") + buf.write("\u016c\u0156\3\2\2\2\u016c\u0159\3\2\2\2\u016c\u015c\3") + buf.write("\2\2\2\u016c\u0160\3\2\2\2\u016c\u0163\3\2\2\2\u016c\u0166") + buf.write("\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c\3\2\2\2\u016e") + buf.write("\u016f\3\2\2\2\u016f\t\3\2\2\2\u0170\u016e\3\2\2\2\u0171") + buf.write("\u017a\5&\24\2\u0172\u017a\5.\30\2\u0173\u017a\5\62\32") + buf.write("\2\u0174\u017a\5\66\34\2\u0175\u017a\5:\36\2\u0176\u017a") + buf.write("\5D#\2\u0177\u017a\5F$\2\u0178\u017a\5L'\2\u0179\u0171") + buf.write("\3\2\2\2\u0179\u0172\3\2\2\2\u0179\u0173\3\2\2\2\u0179") + buf.write("\u0174\3\2\2\2\u0179\u0175\3\2\2\2\u0179\u0176\3\2\2\2") + buf.write("\u0179\u0177\3\2\2\2\u0179\u0178\3\2\2\2\u017a\13\3\2") + buf.write("\2\2\u017b\u0188\5 \21\2\u017c\u0188\5$\23\2\u017d\u0188") + buf.write("\5,\27\2\u017e\u0188\5\60\31\2\u017f\u0188\5\64\33\2\u0180") + buf.write("\u0188\58\35\2\u0181\u0188\5<\37\2\u0182\u0188\5> \2\u0183") + buf.write('\u0188\5@!\2\u0184\u0188\5B"\2\u0185\u0188\5H%\2\u0186') + buf.write("\u0188\5J&\2\u0187\u017b\3\2\2\2\u0187\u017c\3\2\2\2\u0187") + buf.write("\u017d\3\2\2\2\u0187\u017e\3\2\2\2\u0187\u017f\3\2\2\2") + buf.write("\u0187\u0180\3\2\2\2\u0187\u0181\3\2\2\2\u0187\u0182\3") + buf.write("\2\2\2\u0187\u0183\3\2\2\2\u0187\u0184\3\2\2\2\u0187\u0185") + buf.write("\3\2\2\2\u0187\u0186\3\2\2\2\u0188\r\3\2\2\2\u0189\u0191") + buf.write("\5\20\t\2\u018a\u0191\5\22\n\2\u018b\u0191\5\24\13\2\u018c") + buf.write("\u0191\5\26\f\2\u018d\u0191\5\30\r\2\u018e\u0191\5\32") + buf.write("\16\2\u018f\u0191\5\36\20\2\u0190\u0189\3\2\2\2\u0190") + buf.write("\u018a\3\2\2\2\u0190\u018b\3\2\2\2\u0190\u018c\3\2\2\2") + buf.write("\u0190\u018d\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u018f\3") + buf.write("\2\2\2\u0191\17\3\2\2\2\u0192\u0193\7/\2\2\u0193\u0198") + buf.write("\5N(\2\u0194\u0195\7\23\2\2\u0195\u0197\5N(\2\u0196\u0194") + buf.write("\3\2\2\2\u0197\u019a\3\2\2\2\u0198\u0196\3\2\2\2\u0198") + buf.write("\u0199\3\2\2\2\u0199\21\3\2\2\2\u019a\u0198\3\2\2\2\u019b") + buf.write("\u019c\7K\2\2\u019c\u01a1\5P)\2\u019d\u019f\5p9\2\u019e") + buf.write("\u01a0\5r:\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0") + buf.write("\u01a2\3\2\2\2\u01a1\u019d\3\2\2\2\u01a1\u01a2\3\2\2\2") + buf.write("\u01a2\23\3\2\2\2\u01a3\u01a4\7l\2\2\u01a4\u01a5\5\b\5") + buf.write("\2\u01a5\25\3\2\2\2\u01a6\u01a7\7-\2\2\u01a7\u01ac\5T") + buf.write("+\2\u01a8\u01a9\7\23\2\2\u01a9\u01ab\5T+\2\u01aa\u01a8") + buf.write("\3\2\2\2\u01ab\u01ae\3\2\2\2\u01ac\u01aa\3\2\2\2\u01ac") + buf.write("\u01ad\3\2\2\2\u01ad\27\3\2\2\2\u01ae\u01ac\3\2\2\2\u01af") + buf.write("\u01b0\t\7\2\2\u01b0\u01b5\5\u00c0a\2\u01b1\u01b2\7\23") + buf.write("\2\2\u01b2\u01b4\5\u00c0a\2\u01b3\u01b1\3\2\2\2\u01b4") + buf.write("\u01b7\3\2\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2\2\2") + buf.write("\u01b6\31\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01b9\t\b") + buf.write("\2\2\u01b9\u01ba\5\u00c0a\2\u01ba\u01bb\7\23\2\2\u01bb") + buf.write("\u01bc\5\u00c0a\2\u01bc\33\3\2\2\2\u01bd\u01be\7\u00cd") + buf.write("\2\2\u01be\u01bf\5\u00c0a\2\u01bf\u01c0\7\23\2\2\u01c0") + buf.write("\u01c1\5\u00c0a\2\u01c1\u01c2\7\66\2\2\u01c2\u01c7\5\u00d8") + buf.write("m\2\u01c3\u01c4\7\23\2\2\u01c4\u01c6\5\u00d8m\2\u01c5") + buf.write("\u01c3\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7\u01c5\3\2\2\2") + buf.write("\u01c7\u01c8\3\2\2\2\u01c8\35\3\2\2\2\u01c9\u01c7\3\2") + buf.write("\2\2\u01ca\u01cb\7\u00cf\2\2\u01cb\u01d0\5V,\2\u01cc\u01cd") + buf.write("\7\23\2\2\u01cd\u01cf\5V,\2\u01ce\u01cc\3\2\2\2\u01cf") + buf.write("\u01d2\3\2\2\2\u01d0\u01ce\3\2\2\2\u01d0\u01d1\3\2\2\2") + buf.write("\u01d1\37\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d3\u01d4\t\t") + buf.write("\2\2\u01d4\u01d5\7\3\2\2\u01d5\u01d6\5\\/\2\u01d6\u01d7") + buf.write("\5`\61\2\u01d7\u01d8\7\4\2\2\u01d8\u01e0\3\2\2\2\u01d9") + buf.write("\u01da\t\n\2\2\u01da\u01db\7\3\2\2\u01db\u01dc\5Z.\2\u01dc") + buf.write("\u01dd\5`\61\2\u01dd\u01de\7\4\2\2\u01de\u01e0\3\2\2\2") + buf.write("\u01df\u01d3\3\2\2\2\u01df\u01d9\3\2\2\2\u01e0!\3\2\2") + buf.write("\2\u01e1\u01e2\7}\2\2\u01e2\u01e3\7|\2\2\u01e3\u01e4\5") + buf.write("\u00d4k\2\u01e4\u01ed\7\3\2\2\u01e5\u01ea\5t;\2\u01e6") + buf.write("\u01e7\7\23\2\2\u01e7\u01e9\5t;\2\u01e8\u01e6\3\2\2\2") + buf.write("\u01e9\u01ec\3\2\2\2\u01ea\u01e8\3\2\2\2\u01ea\u01eb\3") + buf.write("\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea\3\2\2\2\u01ed\u01e5") + buf.write("\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01ef\3\2\2\2\u01ef") + buf.write("\u01f2\7\4\2\2\u01f0\u01f1\7\u00cb\2\2\u01f1\u01f3\5v") + buf.write("<\2\u01f2\u01f0\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f4") + buf.write("\3\2\2\2\u01f4\u01f5\7\u00ba\2\2\u01f5\u01f6\5\6\4\2\u01f6") + buf.write("\u01f7\7\u0083\2\2\u01f7\u01f8\7|\2\2\u01f8\u0214\3\2") + buf.write("\2\2\u01f9\u01fa\7}\2\2\u01fa\u01fb\7\177\2\2\u01fb\u01fc") + buf.write("\7\u0081\2\2\u01fc\u01fd\5\u008eH\2\u01fd\u01fe\7\3\2") + buf.write("\2\u01fe\u01ff\5\u0090I\2\u01ff\u0200\7\4\2\2\u0200\u0201") + buf.write("\7\u00ba\2\2\u0201\u0202\5\u0094K\2\u0202\u0203\7\u0083") + buf.write("\2\2\u0203\u0204\7\177\2\2\u0204\u0205\7\u0081\2\2\u0205") + buf.write("\u0214\3\2\2\2\u0206\u0207\7}\2\2\u0207\u0208\7\u0080") + buf.write("\2\2\u0208\u0209\7\u0081\2\2\u0209\u020a\5\u008eH\2\u020a") + buf.write("\u020b\7\3\2\2\u020b\u020c\5\u009cO\2\u020c\u020d\7\4") + buf.write("\2\2\u020d\u020e\7\u00ba\2\2\u020e\u020f\5\u0098M\2\u020f") + buf.write("\u0210\7\u0083\2\2\u0210\u0211\7\u0080\2\2\u0211\u0212") + buf.write("\7\u0081\2\2\u0212\u0214\3\2\2\2\u0213\u01e1\3\2\2\2\u0213") + buf.write("\u01f9\3\2\2\2\u0213\u0206\3\2\2\2\u0214#\3\2\2\2\u0215") + buf.write("\u0216\5\u00d4k\2\u0216\u021f\7\3\2\2\u0217\u021c\5*\26") + buf.write("\2\u0218\u0219\7\23\2\2\u0219\u021b\5*\26\2\u021a\u0218") + buf.write("\3\2\2\2\u021b\u021e\3\2\2\2\u021c\u021a\3\2\2\2\u021c") + buf.write("\u021d\3\2\2\2\u021d\u0220\3\2\2\2\u021e\u021c\3\2\2\2") + buf.write("\u021f\u0217\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0221\3") + buf.write("\2\2\2\u0221\u0222\7\4\2\2\u0222\u024f\3\2\2\2\u0223\u0224") + buf.write("\7\30\2\2\u0224\u0225\7\3\2\2\u0225\u0226\5\u00d6l\2\u0226") + buf.write("\u0229\7\3\2\2\u0227\u022a\5\u00bc_\2\u0228\u022a\5X-") + buf.write("\2\u0229\u0227\3\2\2\2\u0229\u0228\3\2\2\2\u0229\u022a") + buf.write("\3\2\2\2\u022a\u0232\3\2\2\2\u022b\u022e\7\23\2\2\u022c") + buf.write("\u022f\5\u00bc_\2\u022d\u022f\5X-\2\u022e\u022c\3\2\2") + buf.write("\2\u022e\u022d\3\2\2\2\u022f\u0231\3\2\2\2\u0230\u022b") + buf.write("\3\2\2\2\u0231\u0234\3\2\2\2\u0232\u0230\3\2\2\2\u0232") + buf.write("\u0233\3\2\2\2\u0233\u0235\3\2\2\2\u0234\u0232\3\2\2\2") + buf.write("\u0235\u0238\7\4\2\2\u0236\u0237\7\u00f2\2\2\u0237\u0239") + buf.write("\7\u00f6\2\2\u0238\u0236\3\2\2\2\u0238\u0239\3\2\2\2\u0239") + buf.write("\u023c\3\2\2\2\u023a\u023b\7\u00cb\2\2\u023b\u023d\5\u0084") + buf.write("C\2\u023c\u023a\3\2\2\2\u023c\u023d\3\2\2\2\u023d\u023e") + buf.write("\3\2\2\2\u023e\u023f\7\4\2\2\u023f\u024f\3\2\2\2\u0240") + buf.write("\u0241\7\u00dc\2\2\u0241\u0242\7\3\2\2\u0242\u0243\5\6") + buf.write("\4\2\u0243\u0246\7\23\2\2\u0244\u0247\5\u00dan\2\u0245") + buf.write("\u0247\5\u008cG\2\u0246\u0244\3\2\2\2\u0246\u0245\3\2") + buf.write("\2\2\u0247\u024a\3\2\2\2\u0248\u0249\7\23\2\2\u0249\u024b") + buf.write("\7\u00f6\2\2\u024a\u0248\3\2\2\2\u024a\u024b\3\2\2\2\u024b") + buf.write("\u024c\3\2\2\2\u024c\u024d\7\4\2\2\u024d\u024f\3\2\2\2") + buf.write("\u024e\u0215\3\2\2\2\u024e\u0223\3\2\2\2\u024e\u0240\3") + buf.write("\2\2\2\u024f%\3\2\2\2\u0250\u0251\5\u00d4k\2\u0251\u025a") + buf.write("\7\3\2\2\u0252\u0257\5(\25\2\u0253\u0254\7\23\2\2\u0254") + buf.write("\u0256\5(\25\2\u0255\u0253\3\2\2\2\u0256\u0259\3\2\2\2") + buf.write("\u0257\u0255\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025b\3") + buf.write("\2\2\2\u0259\u0257\3\2\2\2\u025a\u0252\3\2\2\2\u025a\u025b") + buf.write("\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u025d\7\4\2\2\u025d") + buf.write("\u028a\3\2\2\2\u025e\u025f\7\u00dc\2\2\u025f\u0260\7\3") + buf.write("\2\2\u0260\u0261\5\b\5\2\u0261\u0264\7\23\2\2\u0262\u0265") + buf.write("\5\u00dan\2\u0263\u0265\5\u008cG\2\u0264\u0262\3\2\2\2") + buf.write("\u0264\u0263\3\2\2\2\u0265\u0268\3\2\2\2\u0266\u0267\7") + buf.write("\23\2\2\u0267\u0269\7\u00f6\2\2\u0268\u0266\3\2\2\2\u0268") + buf.write("\u0269\3\2\2\2\u0269\u026a\3\2\2\2\u026a\u026b\7\4\2\2") + buf.write("\u026b\u028a\3\2\2\2\u026c\u026d\7\30\2\2\u026d\u026e") + buf.write("\7\3\2\2\u026e\u026f\5\u00d6l\2\u026f\u0272\7\3\2\2\u0270") + buf.write("\u0273\5\u00c0a\2\u0271\u0273\5X-\2\u0272\u0270\3\2\2") + buf.write("\2\u0272\u0271\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u027b") + buf.write("\3\2\2\2\u0274\u0277\7\23\2\2\u0275\u0278\5\u00c0a\2\u0276") + buf.write("\u0278\5X-\2\u0277\u0275\3\2\2\2\u0277\u0276\3\2\2\2\u0278") + buf.write("\u027a\3\2\2\2\u0279\u0274\3\2\2\2\u027a\u027d\3\2\2\2") + buf.write("\u027b\u0279\3\2\2\2\u027b\u027c\3\2\2\2\u027c\u027e\3") + buf.write("\2\2\2\u027d\u027b\3\2\2\2\u027e\u0281\7\4\2\2\u027f\u0280") + buf.write("\7\u00f2\2\2\u0280\u0282\7\u00f6\2\2\u0281\u027f\3\2\2") + buf.write("\2\u0281\u0282\3\2\2\2\u0282\u0285\3\2\2\2\u0283\u0284") + buf.write("\7\u00cb\2\2\u0284\u0286\5x=\2\u0285\u0283\3\2\2\2\u0285") + buf.write("\u0286\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\7\4\2\2") + buf.write("\u0288\u028a\3\2\2\2\u0289\u0250\3\2\2\2\u0289\u025e\3") + buf.write("\2\2\2\u0289\u026c\3\2\2\2\u028a'\3\2\2\2\u028b\u028e") + buf.write("\5\b\5\2\u028c\u028e\7u\2\2\u028d\u028b\3\2\2\2\u028d") + buf.write("\u028c\3\2\2\2\u028e)\3\2\2\2\u028f\u0292\5\6\4\2\u0290") + buf.write("\u0292\7u\2\2\u0291\u028f\3\2\2\2\u0291\u0290\3\2\2\2") + buf.write("\u0292+\3\2\2\2\u0293\u0294\t\13\2\2\u0294\u0295\7\3\2") + buf.write("\2\u0295\u0296\5\6\4\2\u0296\u0297\7\4\2\2\u0297\u02c4") + buf.write("\3\2\2\2\u0298\u0299\7d\2\2\u0299\u029a\7\3\2\2\u029a") + buf.write("\u02a5\5\6\4\2\u029b\u029c\7\23\2\2\u029c\u029d\5\u00ca") + buf.write("f\2\u029d\u029e\3\2\2\2\u029e\u029f\7\23\2\2\u029f\u02a0") + buf.write("\5\u00caf\2\u02a0\u02a2\3\2\2\2\u02a1\u029b\3\2\2\2\u02a1") + buf.write("\u02a2\3\2\2\2\u02a2\u02a6\3\2\2\2\u02a3\u02a4\7\23\2") + buf.write("\2\u02a4\u02a6\5\u00caf\2\u02a5\u02a1\3\2\2\2\u02a5\u02a3") + buf.write("\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02a8\7\4\2\2\u02a8") + buf.write("\u02c4\3\2\2\2\u02a9\u02aa\7\u0088\2\2\u02aa\u02ab\7\3") + buf.write("\2\2\u02ab\u02ac\5\6\4\2\u02ac\u02ad\7\23\2\2\u02ad\u02b0") + buf.write("\5\6\4\2\u02ae\u02af\7\23\2\2\u02af\u02b1\5\u00caf\2\u02b0") + buf.write("\u02ae\3\2\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b2\3\2\2\2") + buf.write("\u02b2\u02b3\7\4\2\2\u02b3\u02c4\3\2\2\2\u02b4\u02b5\7") + buf.write("\u0087\2\2\u02b5\u02b6\7\3\2\2\u02b6\u02b7\5\6\4\2\u02b7") + buf.write("\u02b8\7\23\2\2\u02b8\u02bb\5\6\4\2\u02b9\u02ba\7\23\2") + buf.write("\2\u02ba\u02bc\5\u00caf\2\u02bb\u02b9\3\2\2\2\u02bb\u02bc") + buf.write("\3\2\2\2\u02bc\u02bf\3\2\2\2\u02bd\u02be\7\23\2\2\u02be") + buf.write("\u02c0\5\u00caf\2\u02bf\u02bd\3\2\2\2\u02bf\u02c0\3\2") + buf.write("\2\2\u02c0\u02c1\3\2\2\2\u02c1\u02c2\7\4\2\2\u02c2\u02c4") + buf.write("\3\2\2\2\u02c3\u0293\3\2\2\2\u02c3\u0298\3\2\2\2\u02c3") + buf.write("\u02a9\3\2\2\2\u02c3\u02b4\3\2\2\2\u02c4-\3\2\2\2\u02c5") + buf.write("\u02c6\t\13\2\2\u02c6\u02c7\7\3\2\2\u02c7\u02c8\5\b\5") + buf.write("\2\u02c8\u02c9\7\4\2\2\u02c9\u02f6\3\2\2\2\u02ca\u02cb") + buf.write("\7d\2\2\u02cb\u02cc\7\3\2\2\u02cc\u02d7\5\b\5\2\u02cd") + buf.write("\u02ce\7\23\2\2\u02ce\u02cf\5\u00ccg\2\u02cf\u02d0\3\2") + buf.write("\2\2\u02d0\u02d1\7\23\2\2\u02d1\u02d2\5\u00ccg\2\u02d2") + buf.write("\u02d4\3\2\2\2\u02d3\u02cd\3\2\2\2\u02d3\u02d4\3\2\2\2") + buf.write("\u02d4\u02d8\3\2\2\2\u02d5\u02d6\7\23\2\2\u02d6\u02d8") + buf.write("\5\u00ccg\2\u02d7\u02d3\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d8") + buf.write("\u02d9\3\2\2\2\u02d9\u02da\7\4\2\2\u02da\u02f6\3\2\2\2") + buf.write("\u02db\u02dc\7\u0088\2\2\u02dc\u02dd\7\3\2\2\u02dd\u02de") + buf.write("\5\b\5\2\u02de\u02df\7\23\2\2\u02df\u02e2\5\b\5\2\u02e0") + buf.write("\u02e1\7\23\2\2\u02e1\u02e3\5\u00ccg\2\u02e2\u02e0\3\2") + buf.write("\2\2\u02e2\u02e3\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e5") + buf.write("\7\4\2\2\u02e5\u02f6\3\2\2\2\u02e6\u02e7\7\u0087\2\2\u02e7") + buf.write("\u02e8\7\3\2\2\u02e8\u02e9\5\b\5\2\u02e9\u02ea\7\23\2") + buf.write("\2\u02ea\u02ed\5\b\5\2\u02eb\u02ec\7\23\2\2\u02ec\u02ee") + buf.write("\5\u00ccg\2\u02ed\u02eb\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee") + buf.write("\u02f1\3\2\2\2\u02ef\u02f0\7\23\2\2\u02f0\u02f2\5\u00cc") + buf.write("g\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f3") + buf.write("\3\2\2\2\u02f3\u02f4\7\4\2\2\u02f4\u02f6\3\2\2\2\u02f5") + buf.write("\u02c5\3\2\2\2\u02f5\u02ca\3\2\2\2\u02f5\u02db\3\2\2\2") + buf.write("\u02f5\u02e6\3\2\2\2\u02f6/\3\2\2\2\u02f7\u02f8\t\f\2") + buf.write("\2\u02f8\u02f9\7\3\2\2\u02f9\u02fa\5\6\4\2\u02fa\u02fb") + buf.write("\7\4\2\2\u02fb\u030d\3\2\2\2\u02fc\u02fd\t\r\2\2\u02fd") + buf.write("\u02fe\7\3\2\2\u02fe\u0301\5\6\4\2\u02ff\u0300\7\23\2") + buf.write("\2\u0300\u0302\5\u00caf\2\u0301\u02ff\3\2\2\2\u0301\u0302") + buf.write("\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0304\7\4\2\2\u0304") + buf.write("\u030d\3\2\2\2\u0305\u0306\t\16\2\2\u0306\u0307\7\3\2") + buf.write("\2\u0307\u0308\5\6\4\2\u0308\u0309\7\23\2\2\u0309\u030a") + buf.write("\5\6\4\2\u030a\u030b\7\4\2\2\u030b\u030d\3\2\2\2\u030c") + buf.write("\u02f7\3\2\2\2\u030c\u02fc\3\2\2\2\u030c\u0305\3\2\2\2") + buf.write("\u030d\61\3\2\2\2\u030e\u030f\t\f\2\2\u030f\u0310\7\3") + buf.write("\2\2\u0310\u0311\5\b\5\2\u0311\u0312\7\4\2\2\u0312\u0324") + buf.write("\3\2\2\2\u0313\u0314\t\r\2\2\u0314\u0315\7\3\2\2\u0315") + buf.write("\u0318\5\b\5\2\u0316\u0317\7\23\2\2\u0317\u0319\5\u00cc") + buf.write("g\2\u0318\u0316\3\2\2\2\u0318\u0319\3\2\2\2\u0319\u031a") + buf.write("\3\2\2\2\u031a\u031b\7\4\2\2\u031b\u0324\3\2\2\2\u031c") + buf.write("\u031d\t\16\2\2\u031d\u031e\7\3\2\2\u031e\u031f\5\b\5") + buf.write("\2\u031f\u0320\7\23\2\2\u0320\u0321\5\b\5\2\u0321\u0322") + buf.write("\7\4\2\2\u0322\u0324\3\2\2\2\u0323\u030e\3\2\2\2\u0323") + buf.write("\u0313\3\2\2\2\u0323\u031c\3\2\2\2\u0324\63\3\2\2\2\u0325") + buf.write("\u0326\7\65\2\2\u0326\u0327\7\3\2\2\u0327\u0328\5\6\4") + buf.write("\2\u0328\u0329\7\23\2\2\u0329\u032a\5\6\4\2\u032a\u032b") + buf.write("\7\23\2\2\u032b\u032c\5\6\4\2\u032c\u032d\7\4\2\2\u032d") + buf.write("\u0346\3\2\2\2\u032e\u032f\7q\2\2\u032f\u0330\7\3\2\2") + buf.write("\u0330\u0331\5\6\4\2\u0331\u0332\7\23\2\2\u0332\u0333") + buf.write("\5\6\4\2\u0333\u0334\7\4\2\2\u0334\u0346\3\2\2\2\u0335") + buf.write("\u0336\79\2\2\u0336\u0337\7\3\2\2\u0337\u0338\5\6\4\2") + buf.write("\u0338\u0339\7\4\2\2\u0339\u0346\3\2\2\2\u033a\u033b\7") + buf.write("E\2\2\u033b\u033c\7\3\2\2\u033c\u033d\5\6\4\2\u033d\u033e") + buf.write("\7\23\2\2\u033e\u0341\5\6\4\2\u033f\u0340\7\23\2\2\u0340") + buf.write("\u0342\5\u00dco\2\u0341\u033f\3\2\2\2\u0341\u0342\3\2") + buf.write("\2\2\u0342\u0343\3\2\2\2\u0343\u0344\7\4\2\2\u0344\u0346") + buf.write("\3\2\2\2\u0345\u0325\3\2\2\2\u0345\u032e\3\2\2\2\u0345") + buf.write("\u0335\3\2\2\2\u0345\u033a\3\2\2\2\u0346\65\3\2\2\2\u0347") + buf.write("\u0348\7\65\2\2\u0348\u0349\7\3\2\2\u0349\u034a\5\b\5") + buf.write("\2\u034a\u034b\7\23\2\2\u034b\u034c\5\b\5\2\u034c\u034d") + buf.write("\7\23\2\2\u034d\u034e\5\b\5\2\u034e\u034f\7\4\2\2\u034f") + buf.write("\u035d\3\2\2\2\u0350\u0351\7q\2\2\u0351\u0352\7\3\2\2") + buf.write("\u0352\u0353\5\b\5\2\u0353\u0354\7\23\2\2\u0354\u0355") + buf.write("\5\b\5\2\u0355\u0356\7\4\2\2\u0356\u035d\3\2\2\2\u0357") + buf.write("\u0358\79\2\2\u0358\u0359\7\3\2\2\u0359\u035a\5\b\5\2") + buf.write("\u035a\u035b\7\4\2\2\u035b\u035d\3\2\2\2\u035c\u0347\3") + buf.write("\2\2\2\u035c\u0350\3\2\2\2\u035c\u0357\3\2\2\2\u035d\67") + buf.write("\3\2\2\2\u035e\u035f\7\u00d2\2\2\u035f\u0361\7\3\2\2\u0360") + buf.write("\u0362\5\6\4\2\u0361\u0360\3\2\2\2\u0361\u0362\3\2\2\2") + buf.write("\u0362\u0363\3\2\2\2\u0363\u03c5\7\4\2\2\u0364\u0365\7") + buf.write("\u00a3\2\2\u0365\u0366\7\3\2\2\u0366\u0369\5\6\4\2\u0367") + buf.write("\u0368\7\23\2\2\u0368\u036a\t\17\2\2\u0369\u0367\3\2\2") + buf.write("\2\u0369\u036a\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036c") + buf.write("\7\4\2\2\u036c\u03c5\3\2\2\2\u036d\u036e\t\20\2\2\u036e") + buf.write("\u036f\7\3\2\2\u036f\u0370\5\6\4\2\u0370\u0371\7\4\2\2") + buf.write("\u0371\u03c5\3\2\2\2\u0372\u0373\7\u00a6\2\2\u0373\u0374") + buf.write("\7\3\2\2\u0374\u0375\5\6\4\2\u0375\u0376\7\23\2\2\u0376") + buf.write("\u0377\5l\67\2\u0377\u0378\7\4\2\2\u0378\u03c5\3\2\2\2") + buf.write("\u0379\u037a\7\u00d5\2\2\u037a\u037b\7\3\2\2\u037b\u037e") + buf.write("\7\u00f6\2\2\u037c\u037d\7\23\2\2\u037d\u037f\t\21\2\2") + buf.write("\u037e\u037c\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u0382\3") + buf.write("\2\2\2\u0380\u0381\7\23\2\2\u0381\u0383\5\u00caf\2\u0382") + buf.write("\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0386\3\2\2\2") + buf.write("\u0384\u0385\7\23\2\2\u0385\u0387\t\22\2\2\u0386\u0384") + buf.write("\3\2\2\2\u0386\u0387\3\2\2\2\u0387\u0388\3\2\2\2\u0388") + buf.write("\u03c5\7\4\2\2\u0389\u038a\7\37\2\2\u038a\u038b\7\3\2") + buf.write("\2\u038b\u03c5\7\4\2\2\u038c\u038d\7 \2\2\u038d\u038e") + buf.write("\7\3\2\2\u038e\u038f\5\6\4\2\u038f\u0390\7\23\2\2\u0390") + buf.write("\u0391\5\6\4\2\u0391\u0392\7\4\2\2\u0392\u03c5\3\2\2\2") + buf.write("\u0393\u0394\7!\2\2\u0394\u0395\7\3\2\2\u0395\u0396\5") + buf.write("\6\4\2\u0396\u0397\7\23\2\2\u0397\u0398\5\6\4\2\u0398") + buf.write("\u0399\7\23\2\2\u0399\u039a\5\6\4\2\u039a\u039b\7\4\2") + buf.write('\2\u039b\u03c5\3\2\2\2\u039c\u039d\7"\2\2\u039d\u039e') + buf.write("\7\3\2\2\u039e\u039f\5\6\4\2\u039f\u03a0\7\4\2\2\u03a0") + buf.write("\u03c5\3\2\2\2\u03a1\u03a2\7#\2\2\u03a2\u03a3\7\3\2\2") + buf.write("\u03a3\u03a4\5\6\4\2\u03a4\u03a5\7\4\2\2\u03a5\u03c5\3") + buf.write("\2\2\2\u03a6\u03a7\7$\2\2\u03a7\u03a8\7\3\2\2\u03a8\u03a9") + buf.write("\5\6\4\2\u03a9\u03aa\7\4\2\2\u03aa\u03c5\3\2\2\2\u03ab") + buf.write("\u03ac\7%\2\2\u03ac\u03ad\7\3\2\2\u03ad\u03ae\5\6\4\2") + buf.write("\u03ae\u03af\7\4\2\2\u03af\u03c5\3\2\2\2\u03b0\u03b1\7") + buf.write("&\2\2\u03b1\u03b2\7\3\2\2\u03b2\u03b3\5\6\4\2\u03b3\u03b4") + buf.write("\7\4\2\2\u03b4\u03c5\3\2\2\2\u03b5\u03b6\7'\2\2\u03b6") + buf.write("\u03b7\7\3\2\2\u03b7\u03b8\5\6\4\2\u03b8\u03b9\7\4\2\2") + buf.write("\u03b9\u03c5\3\2\2\2\u03ba\u03bb\7(\2\2\u03bb\u03bc\7") + buf.write("\3\2\2\u03bc\u03bd\5\6\4\2\u03bd\u03be\7\4\2\2\u03be\u03c5") + buf.write("\3\2\2\2\u03bf\u03c0\7)\2\2\u03c0\u03c1\7\3\2\2\u03c1") + buf.write("\u03c2\5\6\4\2\u03c2\u03c3\7\4\2\2\u03c3\u03c5\3\2\2\2") + buf.write("\u03c4\u035e\3\2\2\2\u03c4\u0364\3\2\2\2\u03c4\u036d\3") + buf.write("\2\2\2\u03c4\u0372\3\2\2\2\u03c4\u0379\3\2\2\2\u03c4\u0389") + buf.write("\3\2\2\2\u03c4\u038c\3\2\2\2\u03c4\u0393\3\2\2\2\u03c4") + buf.write("\u039c\3\2\2\2\u03c4\u03a1\3\2\2\2\u03c4\u03a6\3\2\2\2") + buf.write("\u03c4\u03ab\3\2\2\2\u03c4\u03b0\3\2\2\2\u03c4\u03b5\3") + buf.write("\2\2\2\u03c4\u03ba\3\2\2\2\u03c4\u03bf\3\2\2\2\u03c59") + buf.write("\3\2\2\2\u03c6\u03c7\7\u00d2\2\2\u03c7\u03c9\7\3\2\2\u03c8") + buf.write("\u03ca\5\b\5\2\u03c9\u03c8\3\2\2\2\u03c9\u03ca\3\2\2\2") + buf.write("\u03ca\u03cb\3\2\2\2\u03cb\u042d\7\4\2\2\u03cc\u03cd\7") + buf.write("\u00a3\2\2\u03cd\u03ce\7\3\2\2\u03ce\u03d1\5\b\5\2\u03cf") + buf.write("\u03d0\7\23\2\2\u03d0\u03d2\t\17\2\2\u03d1\u03cf\3\2\2") + buf.write("\2\u03d1\u03d2\3\2\2\2\u03d2\u03d3\3\2\2\2\u03d3\u03d4") + buf.write("\7\4\2\2\u03d4\u042d\3\2\2\2\u03d5\u03d6\t\20\2\2\u03d6") + buf.write("\u03d7\7\3\2\2\u03d7\u03d8\5\b\5\2\u03d8\u03d9\7\4\2\2") + buf.write("\u03d9\u042d\3\2\2\2\u03da\u03db\7\u00a6\2\2\u03db\u03dc") + buf.write("\7\3\2\2\u03dc\u03dd\5\b\5\2\u03dd\u03de\7\23\2\2\u03de") + buf.write("\u03df\5l\67\2\u03df\u03e0\7\4\2\2\u03e0\u042d\3\2\2\2") + buf.write("\u03e1\u03e2\7\u00d5\2\2\u03e2\u03e3\7\3\2\2\u03e3\u03e6") + buf.write("\7\u00f6\2\2\u03e4\u03e5\7\23\2\2\u03e5\u03e7\t\21\2\2") + buf.write("\u03e6\u03e4\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u03ea\3") + buf.write("\2\2\2\u03e8\u03e9\7\23\2\2\u03e9\u03eb\5\u00ccg\2\u03ea") + buf.write("\u03e8\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ee\3\2\2\2") + buf.write("\u03ec\u03ed\7\23\2\2\u03ed\u03ef\t\22\2\2\u03ee\u03ec") + buf.write("\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0") + buf.write("\u042d\7\4\2\2\u03f1\u03f2\7\37\2\2\u03f2\u03f3\7\3\2") + buf.write("\2\u03f3\u042d\7\4\2\2\u03f4\u03f5\7 \2\2\u03f5\u03f6") + buf.write("\7\3\2\2\u03f6\u03f7\5\b\5\2\u03f7\u03f8\7\23\2\2\u03f8") + buf.write("\u03f9\5\b\5\2\u03f9\u03fa\7\4\2\2\u03fa\u042d\3\2\2\2") + buf.write("\u03fb\u03fc\7!\2\2\u03fc\u03fd\7\3\2\2\u03fd\u03fe\5") + buf.write("\b\5\2\u03fe\u03ff\7\23\2\2\u03ff\u0400\5\b\5\2\u0400") + buf.write("\u0401\7\23\2\2\u0401\u0402\5\b\5\2\u0402\u0403\7\4\2") + buf.write('\2\u0403\u042d\3\2\2\2\u0404\u0405\7"\2\2\u0405\u0406') + buf.write("\7\3\2\2\u0406\u0407\5\b\5\2\u0407\u0408\7\4\2\2\u0408") + buf.write("\u042d\3\2\2\2\u0409\u040a\7#\2\2\u040a\u040b\7\3\2\2") + buf.write("\u040b\u040c\5\b\5\2\u040c\u040d\7\4\2\2\u040d\u042d\3") + buf.write("\2\2\2\u040e\u040f\7$\2\2\u040f\u0410\7\3\2\2\u0410\u0411") + buf.write("\5\b\5\2\u0411\u0412\7\4\2\2\u0412\u042d\3\2\2\2\u0413") + buf.write("\u0414\7%\2\2\u0414\u0415\7\3\2\2\u0415\u0416\5\b\5\2") + buf.write("\u0416\u0417\7\4\2\2\u0417\u042d\3\2\2\2\u0418\u0419\7") + buf.write("&\2\2\u0419\u041a\7\3\2\2\u041a\u041b\5\b\5\2\u041b\u041c") + buf.write("\7\4\2\2\u041c\u042d\3\2\2\2\u041d\u041e\7'\2\2\u041e") + buf.write("\u041f\7\3\2\2\u041f\u0420\5\b\5\2\u0420\u0421\7\4\2\2") + buf.write("\u0421\u042d\3\2\2\2\u0422\u0423\7(\2\2\u0423\u0424\7") + buf.write("\3\2\2\u0424\u0425\5\b\5\2\u0425\u0426\7\4\2\2\u0426\u042d") + buf.write("\3\2\2\2\u0427\u0428\7)\2\2\u0428\u0429\7\3\2\2\u0429") + buf.write("\u042a\5\b\5\2\u042a\u042b\7\4\2\2\u042b\u042d\3\2\2\2") + buf.write("\u042c\u03c6\3\2\2\2\u042c\u03cc\3\2\2\2\u042c\u03d5\3") + buf.write("\2\2\2\u042c\u03da\3\2\2\2\u042c\u03e1\3\2\2\2\u042c\u03f1") + buf.write("\3\2\2\2\u042c\u03f4\3\2\2\2\u042c\u03fb\3\2\2\2\u042c") + buf.write("\u0404\3\2\2\2\u042c\u0409\3\2\2\2\u042c\u040e\3\2\2\2") + buf.write("\u042c\u0413\3\2\2\2\u042c\u0418\3\2\2\2\u042c\u041d\3") + buf.write("\2\2\2\u042c\u0422\3\2\2\2\u042c\u0427\3\2\2\2\u042d;") + buf.write("\3\2\2\2\u042e\u042f\7;\2\2\u042f\u0430\7\3\2\2\u0430") + buf.write("\u0433\5\6\4\2\u0431\u0432\7\23\2\2\u0432\u0434\5\6\4") + buf.write("\2\u0433\u0431\3\2\2\2\u0434\u0435\3\2\2\2\u0435\u0433") + buf.write("\3\2\2\2\u0435\u0436\3\2\2\2\u0436\u0437\3\2\2\2\u0437") + buf.write("\u0438\7\4\2\2\u0438\u044c\3\2\2\2\u0439\u043a\7>\2\2") + buf.write("\u043a\u043b\7\3\2\2\u043b\u043e\5\6\4\2\u043c\u043d\7") + buf.write("\23\2\2\u043d\u043f\5\6\4\2\u043e\u043c\3\2\2\2\u043f") + buf.write("\u0440\3\2\2\2\u0440\u043e\3\2\2\2\u0440\u0441\3\2\2\2") + buf.write("\u0441\u0442\3\2\2\2\u0442\u0443\7\4\2\2\u0443\u044c\3") + buf.write("\2\2\2\u0444\u0445\t\23\2\2\u0445\u0446\7\3\2\2\u0446") + buf.write("\u0447\5\6\4\2\u0447\u0448\7\23\2\2\u0448\u0449\5\6\4") + buf.write("\2\u0449\u044a\7\4\2\2\u044a\u044c\3\2\2\2\u044b\u042e") + buf.write("\3\2\2\2\u044b\u0439\3\2\2\2\u044b\u0444\3\2\2\2\u044c") + buf.write("=\3\2\2\2\u044d\u044e\7t\2\2\u044e\u044f\7\3\2\2\u044f") + buf.write("\u0450\5\6\4\2\u0450\u0451\7\23\2\2\u0451\u0453\7\u00f7") + buf.write("\2\2\u0452\u0454\5\u00b0Y\2\u0453\u0452\3\2\2\2\u0453") + buf.write("\u0454\3\2\2\2\u0454\u0457\3\2\2\2\u0455\u0456\7\u0082") + buf.write("\2\2\u0456\u0458\5\u00c0a\2\u0457\u0455\3\2\2\2\u0457") + buf.write("\u0458\3\2\2\2\u0458\u045a\3\2\2\2\u0459\u045b\5\u00ae") + buf.write("X\2\u045a\u0459\3\2\2\2\u045a\u045b\3\2\2\2\u045b\u045d") + buf.write("\3\2\2\2\u045c\u045e\5\u00b6\\\2\u045d\u045c\3\2\2\2\u045d") + buf.write("\u045e\3\2\2\2\u045e\u0460\3\2\2\2\u045f\u0461\5\u00b8") + buf.write("]\2\u0460\u045f\3\2\2\2\u0460\u0461\3\2\2\2\u0461\u0462") + buf.write("\3\2\2\2\u0462\u0463\7\4\2\2\u0463?\3\2\2\2\u0464\u0465") + buf.write("\7\u00e0\2\2\u0465\u0466\7\3\2\2\u0466\u0467\5\6\4\2\u0467") + buf.write("\u0468\7\23\2\2\u0468\u0472\7\u00f7\2\2\u0469\u046a\7") + buf.write("\u00e9\2\2\u046a\u046f\5\u00c0a\2\u046b\u046c\7\23\2\2") + buf.write("\u046c\u046e\5\u00c0a\2\u046d\u046b\3\2\2\2\u046e\u0471") + buf.write("\3\2\2\2\u046f\u046d\3\2\2\2\u046f\u0470\3\2\2\2\u0470") + buf.write("\u0473\3\2\2\2\u0471\u046f\3\2\2\2\u0472\u0469\3\2\2\2") + buf.write("\u0472\u0473\3\2\2\2\u0473\u0475\3\2\2\2\u0474\u0476\5") + buf.write("\u00acW\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476") buf.write("\u0477\3\2\2\2\u0477\u0478\7\4\2\2\u0478\u04a2\3\2\2\2") buf.write("\u0479\u047a\7\u00e1\2\2\u047a\u047b\7\3\2\2\u047b\u047c") buf.write("\5\6\4\2\u047c\u047d\7\23\2\2\u047d\u047f\7\u00f7\2\2") @@ -731,223 +735,228 @@ def serializedATN(): buf.write("\u054b\7\26\2\2\u054b\u054c\5\b\5\2\u054cU\3\2\2\2\u054d") buf.write("\u054e\5\u00c0a\2\u054e\u0551\7\t\2\2\u054f\u0552\5X-") buf.write("\2\u0550\u0552\5\u00bc_\2\u0551\u054f\3\2\2\2\u0551\u0550") - buf.write("\3\2\2\2\u0552W\3\2\2\2\u0553\u0560\5\u00d8m\2\u0554\u0555") + buf.write("\3\2\2\2\u0552W\3\2\2\2\u0553\u056b\5\u00d8m\2\u0554\u0555") buf.write("\7\u00dc\2\2\u0555\u0556\7\3\2\2\u0556\u0557\5\u00d8m") buf.write("\2\u0557\u0558\7\23\2\2\u0558\u055b\5\u00dan\2\u0559\u055a") buf.write("\7\23\2\2\u055a\u055c\7\u00f6\2\2\u055b\u0559\3\2\2\2") buf.write("\u055b\u055c\3\2\2\2\u055c\u055d\3\2\2\2\u055d\u055e\7") - buf.write("\4\2\2\u055e\u0560\3\2\2\2\u055f\u0553\3\2\2\2\u055f\u0554") - buf.write("\3\2\2\2\u0560Y\3\2\2\2\u0561\u0566\5^\60\2\u0562\u0563") - buf.write("\7\23\2\2\u0563\u0565\5^\60\2\u0564\u0562\3\2\2\2\u0565") - buf.write("\u0568\3\2\2\2\u0566\u0564\3\2\2\2\u0566\u0567\3\2\2\2") - buf.write("\u0567[\3\2\2\2\u0568\u0566\3\2\2\2\u0569\u056e\5^\60") - buf.write("\2\u056a\u056b\7\23\2\2\u056b\u056d\5^\60\2\u056c\u056a") - buf.write("\3\2\2\2\u056d\u0570\3\2\2\2\u056e\u056c\3\2\2\2\u056e") - buf.write("\u056f\3\2\2\2\u056f\u057a\3\2\2\2\u0570\u056e\3\2\2\2") - buf.write("\u0571\u0572\7\35\2\2\u0572\u0577\5\u00c0a\2\u0573\u0574") - buf.write("\7\23\2\2\u0574\u0576\5\u00c0a\2\u0575\u0573\3\2\2\2\u0576") - buf.write("\u0579\3\2\2\2\u0577\u0575\3\2\2\2\u0577\u0578\3\2\2\2") - buf.write("\u0578\u057b\3\2\2\2\u0579\u0577\3\2\2\2\u057a\u0571\3") - buf.write("\2\2\2\u057a\u057b\3\2\2\2\u057b]\3\2\2\2\u057c\u057f") - buf.write("\5\6\4\2\u057d\u057e\7\60\2\2\u057e\u0580\5\u00ba^\2\u057f") - buf.write("\u057d\3\2\2\2\u057f\u0580\3\2\2\2\u0580_\3\2\2\2\u0581") - buf.write("\u0583\5\24\13\2\u0582\u0581\3\2\2\2\u0582\u0583\3\2\2") - buf.write("\2\u0583\u0587\3\2\2\2\u0584\u0588\5\26\f\2\u0585\u0588") - buf.write("\5b\62\2\u0586\u0588\5\22\n\2\u0587\u0584\3\2\2\2\u0587") - buf.write("\u0585\3\2\2\2\u0587\u0586\3\2\2\2\u0587\u0588\3\2\2\2") - buf.write("\u0588\u058a\3\2\2\2\u0589\u058b\5\30\r\2\u058a\u0589") - buf.write("\3\2\2\2\u058a\u058b\3\2\2\2\u058b\u058d\3\2\2\2\u058c") - buf.write("\u058e\5\20\t\2\u058d\u058c\3\2\2\2\u058d\u058e\3\2\2") - buf.write("\2\u058ea\3\2\2\2\u058f\u0590\7\u00d0\2\2\u0590\u0591") - buf.write("\5\6\4\2\u0591c\3\2\2\2\u0592\u0593\7\u009e\2\2\u0593") - buf.write("\u0594\7N\2\2\u0594\u0599\5\u00c0a\2\u0595\u0596\7\23") - buf.write("\2\2\u0596\u0598\5\u00c0a\2\u0597\u0595\3\2\2\2\u0598") - buf.write("\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2") - buf.write("\u059ae\3\2\2\2\u059b\u0599\3\2\2\2\u059c\u059d\7M\2\2") - buf.write("\u059d\u059e\7N\2\2\u059e\u05a3\5h\65\2\u059f\u05a0\7") - buf.write("\23\2\2\u05a0\u05a2\5h\65\2\u05a1\u059f\3\2\2\2\u05a2") - buf.write("\u05a5\3\2\2\2\u05a3\u05a1\3\2\2\2\u05a3\u05a4\3\2\2\2") - buf.write("\u05a4g\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a6\u05a8\5\u00c0") - buf.write("a\2\u05a7\u05a9\t\30\2\2\u05a8\u05a7\3\2\2\2\u05a8\u05a9") - buf.write("\3\2\2\2\u05a9i\3\2\2\2\u05aa\u05ab\7y\2\2\u05ab\u05ae") - buf.write("\7\u00be\2\2\u05ac\u05ae\7\u00a0\2\2\u05ad\u05aa\3\2\2") - buf.write("\2\u05ad\u05ac\3\2\2\2\u05ae\u05af\3\2\2\2\u05af\u05b0") - buf.write("\7\65\2\2\u05b0\u05b1\5n8\2\u05b1\u05b2\7\61\2\2\u05b2") - buf.write("\u05b3\5n8\2\u05b3k\3\2\2\2\u05b4\u05b5\7\u00f3\2\2\u05b5") - buf.write("m\3\2\2\2\u05b6\u05b7\7\u00f3\2\2\u05b7\u05c2\7\u009b") - buf.write("\2\2\u05b8\u05b9\7\u00f3\2\2\u05b9\u05c2\7\u009c\2\2\u05ba") - buf.write("\u05bb\7\u00a1\2\2\u05bb\u05bc\7y\2\2\u05bc\u05c2\7\u00bf") - buf.write("\2\2\u05bd\u05be\7\u009d\2\2\u05be\u05c2\7\u009b\2\2\u05bf") - buf.write("\u05c0\7\u009d\2\2\u05c0\u05c2\7\u009c\2\2\u05c1\u05b6") - buf.write("\3\2\2\2\u05c1\u05b8\3\2\2\2\u05c1\u05ba\3\2\2\2\u05c1") - buf.write("\u05bd\3\2\2\2\u05c1\u05bf\3\2\2\2\u05c2o\3\2\2\2\u05c3") - buf.write("\u05c4\7\u0092\2\2\u05c4\u05c5\t\31\2\2\u05c5\u05ca\5") - buf.write("\u00c0a\2\u05c6\u05c7\7\23\2\2\u05c7\u05c9\5\u00c0a\2") - buf.write("\u05c8\u05c6\3\2\2\2\u05c9\u05cc\3\2\2\2\u05ca\u05c8\3") - buf.write("\2\2\2\u05ca\u05cb\3\2\2\2\u05cb\u05d1\3\2\2\2\u05cc\u05ca") - buf.write("\3\2\2\2\u05cd\u05ce\7\u0092\2\2\u05ce\u05cf\7J\2\2\u05cf") - buf.write("\u05d1\5\b\5\2\u05d0\u05c3\3\2\2\2\u05d0\u05cd\3\2\2\2") - buf.write("\u05d1q\3\2\2\2\u05d2\u05d3\7\u0094\2\2\u05d3\u05d4\5") - buf.write("\b\5\2\u05d4s\3\2\2\2\u05d5\u05d6\5\u00bc_\2\u05d6\u05d9") - buf.write("\5z>\2\u05d7\u05d8\7\u00df\2\2\u05d8\u05da\5X-\2\u05d9") - buf.write("\u05d7\3\2\2\2\u05d9\u05da\3\2\2\2\u05dau\3\2\2\2\u05db") - buf.write("\u05df\5~@\2\u05dc\u05df\5\u0082B\2\u05dd\u05df\5\u0080") - buf.write("A\2\u05de\u05db\3\2\2\2\u05de\u05dc\3\2\2\2\u05de\u05dd") - buf.write("\3\2\2\2\u05dfw\3\2\2\2\u05e0\u05e3\5\u0080A\2\u05e1\u05e3") - buf.write("\5~@\2\u05e2\u05e0\3\2\2\2\u05e2\u05e1\3\2\2\2\u05e3y") - buf.write("\3\2\2\2\u05e4\u05ea\5~@\2\u05e5\u05ea\5\u0082B\2\u05e6") - buf.write("\u05ea\5\u0086D\2\u05e7\u05ea\5|?\2\u05e8\u05ea\5\u0080") - buf.write("A\2\u05e9\u05e4\3\2\2\2\u05e9\u05e5\3\2\2\2\u05e9\u05e6") - buf.write("\3\2\2\2\u05e9\u05e7\3\2\2\2\u05e9\u05e8\3\2\2\2\u05ea") - buf.write("{\3\2\2\2\u05eb\u05ef\7\u0081\2\2\u05ec\u05ef\5\u0088") - buf.write("E\2\u05ed\u05ef\5\u008aF\2\u05ee\u05eb\3\2\2\2\u05ee\u05ec") - buf.write("\3\2\2\2\u05ee\u05ed\3\2\2\2\u05ef}\3\2\2\2\u05f0\u05f3") - buf.write("\5\u00dan\2\u05f1\u05f3\5\u008cG\2\u05f2\u05f0\3\2\2\2") - buf.write("\u05f2\u05f1\3\2\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f6\5") - buf.write("\u00a6T\2\u05f5\u05f4\3\2\2\2\u05f5\u05f6\3\2\2\2\u05f6") - buf.write("\u05fb\3\2\2\2\u05f7\u05f9\7\64\2\2\u05f8\u05f7\3\2\2") - buf.write("\2\u05f8\u05f9\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fc") - buf.write("\78\2\2\u05fb\u05f8\3\2\2\2\u05fb\u05fc\3\2\2\2\u05fc") - buf.write("\177\3\2\2\2\u05fd\u0602\5\u00ceh\2\u05fe\u05ff\7\n\2") - buf.write("\2\u05ff\u0600\5~@\2\u0600\u0601\7\13\2\2\u0601\u0603") - buf.write("\3\2\2\2\u0602\u05fe\3\2\2\2\u0602\u0603\3\2\2\2\u0603") - buf.write("\u0081\3\2\2\2\u0604\u0610\7{\2\2\u0605\u0606\7\7\2\2") - buf.write("\u0606\u060b\5\u00a8U\2\u0607\u0608\7\23\2\2\u0608\u060a") - buf.write("\5\u00a8U\2\u0609\u0607\3\2\2\2\u060a\u060d\3\2\2\2\u060b") - buf.write("\u0609\3\2\2\2\u060b\u060c\3\2\2\2\u060c\u060e\3\2\2\2") - buf.write("\u060d\u060b\3\2\2\2\u060e\u060f\7\b\2\2\u060f\u0611\3") - buf.write("\2\2\2\u0610\u0605\3\2\2\2\u0610\u0611\3\2\2\2\u0611\u0083") - buf.write("\3\2\2\2\u0612\u0615\5\u0082B\2\u0613\u0615\5~@\2\u0614") - buf.write("\u0612\3\2\2\2\u0614\u0613\3\2\2\2\u0615\u0085\3\2\2\2") - buf.write("\u0616\u061b\7\u00f1\2\2\u0617\u0618\7\n\2\2\u0618\u0619") - buf.write("\5~@\2\u0619\u061a\7\13\2\2\u061a\u061c\3\2\2\2\u061b") - buf.write("\u0617\3\2\2\2\u061b\u061c\3\2\2\2\u061c\u0087\3\2\2\2") - buf.write("\u061d\u063b\7\177\2\2\u061e\u062a\7\u00ed\2\2\u061f\u0620") - buf.write("\7\7\2\2\u0620\u0625\5\u008cG\2\u0621\u0622\7\21\2\2\u0622") - buf.write("\u0624\5\u008cG\2\u0623\u0621\3\2\2\2\u0624\u0627\3\2") - buf.write("\2\2\u0625\u0623\3\2\2\2\u0625\u0626\3\2\2\2\u0626\u0628") - buf.write("\3\2\2\2\u0627\u0625\3\2\2\2\u0628\u0629\7\b\2\2\u0629") - buf.write("\u062b\3\2\2\2\u062a\u061f\3\2\2\2\u062a\u062b\3\2\2\2") - buf.write("\u062b\u063b\3\2\2\2\u062c\u0638\7\u00ee\2\2\u062d\u062e") - buf.write("\7\7\2\2\u062e\u0633\5\u00bc_\2\u062f\u0630\7\21\2\2\u0630") - buf.write("\u0632\5\u00bc_\2\u0631\u062f\3\2\2\2\u0632\u0635\3\2") - buf.write("\2\2\u0633\u0631\3\2\2\2\u0633\u0634\3\2\2\2\u0634\u0636") - buf.write("\3\2\2\2\u0635\u0633\3\2\2\2\u0636\u0637\7\b\2\2\u0637") - buf.write("\u0639\3\2\2\2\u0638\u062d\3\2\2\2\u0638\u0639\3\2\2\2") - buf.write("\u0639\u063b\3\2\2\2\u063a\u061d\3\2\2\2\u063a\u061e\3") - buf.write("\2\2\2\u063a\u062c\3\2\2\2\u063b\u0089\3\2\2\2\u063c\u0665") - buf.write("\7\u0080\2\2\u063d\u064e\7\u00ef\2\2\u063e\u063f\7\7\2") - buf.write("\2\u063f\u064b\7\u00f7\2\2\u0640\u0641\7\3\2\2\u0641\u0646") - buf.write("\5\u008cG\2\u0642\u0643\7\21\2\2\u0643\u0645\5\u008cG") - buf.write("\2\u0644\u0642\3\2\2\2\u0645\u0648\3\2\2\2\u0646\u0644") - buf.write("\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u0649\3\2\2\2\u0648") - buf.write("\u0646\3\2\2\2\u0649\u064a\7\4\2\2\u064a\u064c\3\2\2\2") - buf.write("\u064b\u0640\3\2\2\2\u064b\u064c\3\2\2\2\u064c\u064d\3") - buf.write("\2\2\2\u064d\u064f\7\b\2\2\u064e\u063e\3\2\2\2\u064e\u064f") - buf.write("\3\2\2\2\u064f\u0665\3\2\2\2\u0650\u0662\7\u00f0\2\2\u0651") - buf.write("\u0652\7\7\2\2\u0652\u065e\5\u00bc_\2\u0653\u0654\7\3") - buf.write("\2\2\u0654\u0659\5\u00bc_\2\u0655\u0656\7\21\2\2\u0656") - buf.write("\u0658\5\u00bc_\2\u0657\u0655\3\2\2\2\u0658\u065b\3\2") - buf.write("\2\2\u0659\u0657\3\2\2\2\u0659\u065a\3\2\2\2\u065a\u065c") - buf.write("\3\2\2\2\u065b\u0659\3\2\2\2\u065c\u065d\7\4\2\2\u065d") - buf.write("\u065f\3\2\2\2\u065e\u0653\3\2\2\2\u065e\u065f\3\2\2\2") - buf.write("\u065f\u0660\3\2\2\2\u0660\u0661\7\b\2\2\u0661\u0663\3") - buf.write("\2\2\2\u0662\u0651\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0665") - buf.write("\3\2\2\2\u0664\u063c\3\2\2\2\u0664\u063d\3\2\2\2\u0664") - buf.write("\u0650\3\2\2\2\u0665\u008b\3\2\2\2\u0666\u0667\7\u00f7") - buf.write("\2\2\u0667\u008d\3\2\2\2\u0668\u0669\7\u00f7\2\2\u0669") - buf.write("\u008f\3\2\2\2\u066a\u066b\t\32\2\2\u066b\u0670\5\u0092") - buf.write("J\2\u066c\u066d\7\23\2\2\u066d\u066f\5\u0092J\2\u066e") - buf.write("\u066c\3\2\2\2\u066f\u0672\3\2\2\2\u0670\u066e\3\2\2\2") - buf.write("\u0670\u0671\3\2\2\2\u0671\u0091\3\2\2\2\u0672\u0670\3") - buf.write("\2\2\2\u0673\u0676\5\u00bc_\2\u0674\u0675\7\60\2\2\u0675") - buf.write("\u0677\5\u00ba^\2\u0676\u0674\3\2\2\2\u0676\u0677\3\2") - buf.write("\2\2\u0677\u0093\3\2\2\2\u0678\u067d\5\u0096L\2\u0679") - buf.write("\u067a\7\u00f9\2\2\u067a\u067c\5\u0096L\2\u067b\u0679") - buf.write("\3\2\2\2\u067c\u067f\3\2\2\2\u067d\u067b\3\2\2\2\u067d") - buf.write("\u067e\3\2\2\2\u067e\u0095\3\2\2\2\u067f\u067d\3\2\2\2") - buf.write("\u0680\u0681\7\u00f7\2\2\u0681\u0683\7\25\2\2\u0682\u0680") - buf.write("\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u0688\3\2\2\2\u0684") - buf.write("\u0685\7\u00bb\2\2\u0685\u0686\5\b\5\2\u0686\u0687\7\33") - buf.write("\2\2\u0687\u0689\3\2\2\2\u0688\u0684\3\2\2\2\u0688\u0689") - buf.write("\3\2\2\2\u0689\u068a\3\2\2\2\u068a\u068c\5\b\5\2\u068b") - buf.write("\u068d\5\u00c4c\2\u068c\u068b\3\2\2\2\u068c\u068d\3\2") - buf.write("\2\2\u068d\u068f\3\2\2\2\u068e\u0690\5\u00c6d\2\u068f") - buf.write("\u068e\3\2\2\2\u068f\u0690\3\2\2\2\u0690\u0097\3\2\2\2") - buf.write("\u0691\u0696\5\u009aN\2\u0692\u0693\7\u00f9\2\2\u0693") - buf.write("\u0695\5\u009aN\2\u0694\u0692\3\2\2\2\u0695\u0698\3\2") - buf.write("\2\2\u0696\u0694\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0099") - buf.write("\3\2\2\2\u0698\u0696\3\2\2\2\u0699\u069a\7\u00f7\2\2\u069a") - buf.write("\u069c\7\25\2\2\u069b\u0699\3\2\2\2\u069b\u069c\3\2\2") - buf.write("\2\u069c\u069d\3\2\2\2\u069d\u069f\5\u00a0Q\2\u069e\u06a0") - buf.write("\5\u00c4c\2\u069f\u069e\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0") - buf.write("\u06a2\3\2\2\2\u06a1\u06a3\5\u00c6d\2\u06a2\u06a1\3\2") - buf.write("\2\2\u06a2\u06a3\3\2\2\2\u06a3\u009b\3\2\2\2\u06a4\u06a7") - buf.write("\t\32\2\2\u06a5\u06a6\7\u00a9\2\2\u06a6\u06a8\5\u009e") - buf.write("P\2\u06a7\u06a5\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8\u06a9") - buf.write("\3\2\2\2\u06a9\u06aa\7\u0082\2\2\u06aa\u06ab\7\u00f7\2") - buf.write("\2\u06ab\u009d\3\2\2\2\u06ac\u06b1\5\u0092J\2\u06ad\u06ae") - buf.write("\7\23\2\2\u06ae\u06b0\5\u0092J\2\u06af\u06ad\3\2\2\2\u06b0") - buf.write("\u06b3\3\2\2\2\u06b1\u06af\3\2\2\2\u06b1\u06b2\3\2\2\2") - buf.write("\u06b2\u009f\3\2\2\2\u06b3\u06b1\3\2\2\2\u06b4\u06b5\7") - buf.write("\u00bb\2\2\u06b5\u06b6\5\b\5\2\u06b6\u06b7\7\33\2\2\u06b7") - buf.write("\u06b9\3\2\2\2\u06b8\u06b4\3\2\2\2\u06b8\u06b9\3\2\2\2") - buf.write("\u06b9\u06ba\3\2\2\2\u06ba\u06bc\5\u00a4S\2\u06bb\u06bd") - buf.write("\5\u00c8e\2\u06bc\u06bb\3\2\2\2\u06bc\u06bd\3\2\2\2\u06bd") - buf.write("\u06be\3\2\2\2\u06be\u06c2\5\u00a2R\2\u06bf\u06c1\5\u00a2") - buf.write("R\2\u06c0\u06bf\3\2\2\2\u06c1\u06c4\3\2\2\2\u06c2\u06c0") - buf.write("\3\2\2\2\u06c2\u06c3\3\2\2\2\u06c3\u00a1\3\2\2\2\u06c4") - buf.write("\u06c2\3\2\2\2\u06c5\u06c7\t\33\2\2\u06c6\u06c5\3\2\2") - buf.write("\2\u06c6\u06c7\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cd") - buf.write("\5\u00a4S\2\u06c9\u06ca\7\5\2\2\u06ca\u06cb\5\b\5\2\u06cb") - buf.write("\u06cc\7\6\2\2\u06cc\u06ce\3\2\2\2\u06cd\u06c9\3\2\2\2") - buf.write("\u06cd\u06ce\3\2\2\2\u06ce\u00a3\3\2\2\2\u06cf\u06d0\t") - buf.write("\34\2\2\u06d0\u00a5\3\2\2\2\u06d1\u06d2\7\5\2\2\u06d2") - buf.write("\u06d3\5\b\5\2\u06d3\u06d4\7\6\2\2\u06d4\u06e1\3\2\2\2") - buf.write("\u06d5\u06d6\7\7\2\2\u06d6\u06db\5X-\2\u06d7\u06d8\7\23") - buf.write("\2\2\u06d8\u06da\5X-\2\u06d9\u06d7\3\2\2\2\u06da\u06dd") - buf.write("\3\2\2\2\u06db\u06d9\3\2\2\2\u06db\u06dc\3\2\2\2\u06dc") - buf.write("\u06de\3\2\2\2\u06dd\u06db\3\2\2\2\u06de\u06df\7\b\2\2") - buf.write("\u06df\u06e1\3\2\2\2\u06e0\u06d1\3\2\2\2\u06e0\u06d5\3") - buf.write("\2\2\2\u06e1\u00a7\3\2\2\2\u06e2\u06e5\5\u0080A\2\u06e3") - buf.write("\u06e6\5\u00c0a\2\u06e4\u06e6\5\u00aaV\2\u06e5\u06e3\3") - buf.write("\2\2\2\u06e5\u06e4\3\2\2\2\u06e6\u00a9\3\2\2\2\u06e7\u06e9") - buf.write("\7u\2\2\u06e8\u06ea\t\35\2\2\u06e9\u06e8\3\2\2\2\u06e9") - buf.write("\u06ea\3\2\2\2\u06ea\u00ab\3\2\2\2\u06eb\u06ec\t\36\2") - buf.write("\2\u06ec\u00ad\3\2\2\2\u06ed\u06ee\t\37\2\2\u06ee\u00af") - buf.write("\3\2\2\2\u06ef\u06f0\7\u00a9\2\2\u06f0\u06f5\5\u00c0a") - buf.write("\2\u06f1\u06f2\7\23\2\2\u06f2\u06f4\5\u00c0a\2\u06f3\u06f1") - buf.write("\3\2\2\2\u06f4\u06f7\3\2\2\2\u06f5\u06f3\3\2\2\2\u06f5") - buf.write("\u06f6\3\2\2\2\u06f6\u00b1\3\2\2\2\u06f7\u06f5\3\2\2\2") - buf.write("\u06f8\u06f9\t \2\2\u06f9\u00b3\3\2\2\2\u06fa\u06fb\7") - buf.write("H\2\2\u06fb\u06fc\5\6\4\2\u06fc\u00b5\3\2\2\2\u06fd\u06fe") - buf.write('\t!\2\2\u06fe\u00b7\3\2\2\2\u06ff\u0700\t"\2\2\u0700') - buf.write("\u00b9\3\2\2\2\u0701\u0702\7\u00f7\2\2\u0702\u00bb\3\2") - buf.write("\2\2\u0703\u0704\7\u00f7\2\2\u0704\u00bd\3\2\2\2\u0705") - buf.write("\u0706\7\u00f7\2\2\u0706\u00bf\3\2\2\2\u0707\u070a\7\u00f7") - buf.write("\2\2\u0708\u0709\7\27\2\2\u0709\u070b\7\u00f7\2\2\u070a") - buf.write("\u0708\3\2\2\2\u070a\u070b\3\2\2\2\u070b\u00c1\3\2\2\2") - buf.write("\u070c\u070d\7\7\2\2\u070d\u0712\5X-\2\u070e\u070f\7\23") - buf.write("\2\2\u070f\u0711\5X-\2\u0710\u070e\3\2\2\2\u0711\u0714") - buf.write("\3\2\2\2\u0712\u0710\3\2\2\2\u0712\u0713\3\2\2\2\u0713") - buf.write("\u0715\3\2\2\2\u0714\u0712\3\2\2\2\u0715\u0716\7\b\2\2") - buf.write("\u0716\u00c3\3\2\2\2\u0717\u0718\7I\2\2\u0718\u0719\5") - buf.write("\u00d8m\2\u0719\u00c5\3\2\2\2\u071a\u071b\7L\2\2\u071b") - buf.write("\u071c\5\u00d8m\2\u071c\u00c7\3\2\2\2\u071d\u071e\t#\2") - buf.write("\2\u071e\u00c9\3\2\2\2\u071f\u0722\5\6\4\2\u0720\u0722") - buf.write("\7u\2\2\u0721\u071f\3\2\2\2\u0721\u0720\3\2\2\2\u0722") - buf.write("\u00cb\3\2\2\2\u0723\u0726\5\b\5\2\u0724\u0726\7u\2\2") - buf.write("\u0725\u0723\3\2\2\2\u0725\u0724\3\2\2\2\u0726\u00cd\3") - buf.write("\2\2\2\u0727\u072d\7j\2\2\u0728\u072d\7\u00ec\2\2\u0729") - buf.write("\u072d\7i\2\2\u072a\u072d\7k\2\2\u072b\u072d\5\u00d0i") - buf.write("\2\u072c\u0727\3\2\2\2\u072c\u0728\3\2\2\2\u072c\u0729") - buf.write("\3\2\2\2\u072c\u072a\3\2\2\2\u072c\u072b\3\2\2\2\u072d") - buf.write("\u00cf\3\2\2\2\u072e\u072f\7p\2\2\u072f\u0730\7k\2\2\u0730") - buf.write("\u00d1\3\2\2\2\u0731\u0732\7\u00f7\2\2\u0732\u00d3\3\2") - buf.write("\2\2\u0733\u0734\7\u00f7\2\2\u0734\u00d5\3\2\2\2\u0735") - buf.write("\u0736\7\u00f7\2\2\u0736\u00d7\3\2\2\2\u0737\u0738\t$") - buf.write("\2\2\u0738\u00d9\3\2\2\2\u0739\u073a\t%\2\2\u073a\u00db") - buf.write("\3\2\2\2\u073b\u073c\t&\2\2\u073c\u00dd\3\2\2\2\u00c5") + buf.write("\4\2\2\u055e\u056b\3\2\2\2\u055f\u0560\7\u00dc\2\2\u0560") + buf.write("\u0561\7\3\2\2\u0561\u0562\5\u00bc_\2\u0562\u0563\7\23") + buf.write("\2\2\u0563\u0566\5\u00dan\2\u0564\u0565\7\23\2\2\u0565") + buf.write("\u0567\7\u00f6\2\2\u0566\u0564\3\2\2\2\u0566\u0567\3\2") + buf.write("\2\2\u0567\u0568\3\2\2\2\u0568\u0569\7\4\2\2\u0569\u056b") + buf.write("\3\2\2\2\u056a\u0553\3\2\2\2\u056a\u0554\3\2\2\2\u056a") + buf.write("\u055f\3\2\2\2\u056bY\3\2\2\2\u056c\u0571\5^\60\2\u056d") + buf.write("\u056e\7\23\2\2\u056e\u0570\5^\60\2\u056f\u056d\3\2\2") + buf.write("\2\u0570\u0573\3\2\2\2\u0571\u056f\3\2\2\2\u0571\u0572") + buf.write("\3\2\2\2\u0572[\3\2\2\2\u0573\u0571\3\2\2\2\u0574\u0579") + buf.write("\5^\60\2\u0575\u0576\7\23\2\2\u0576\u0578\5^\60\2\u0577") + buf.write("\u0575\3\2\2\2\u0578\u057b\3\2\2\2\u0579\u0577\3\2\2\2") + buf.write("\u0579\u057a\3\2\2\2\u057a\u0585\3\2\2\2\u057b\u0579\3") + buf.write("\2\2\2\u057c\u057d\7\35\2\2\u057d\u0582\5\u00c0a\2\u057e") + buf.write("\u057f\7\23\2\2\u057f\u0581\5\u00c0a\2\u0580\u057e\3\2") + buf.write("\2\2\u0581\u0584\3\2\2\2\u0582\u0580\3\2\2\2\u0582\u0583") + buf.write("\3\2\2\2\u0583\u0586\3\2\2\2\u0584\u0582\3\2\2\2\u0585") + buf.write("\u057c\3\2\2\2\u0585\u0586\3\2\2\2\u0586]\3\2\2\2\u0587") + buf.write("\u058a\5\6\4\2\u0588\u0589\7\60\2\2\u0589\u058b\5\u00ba") + buf.write("^\2\u058a\u0588\3\2\2\2\u058a\u058b\3\2\2\2\u058b_\3\2") + buf.write("\2\2\u058c\u058e\5\24\13\2\u058d\u058c\3\2\2\2\u058d\u058e") + buf.write("\3\2\2\2\u058e\u0592\3\2\2\2\u058f\u0593\5\26\f\2\u0590") + buf.write("\u0593\5b\62\2\u0591\u0593\5\22\n\2\u0592\u058f\3\2\2") + buf.write("\2\u0592\u0590\3\2\2\2\u0592\u0591\3\2\2\2\u0592\u0593") + buf.write("\3\2\2\2\u0593\u0595\3\2\2\2\u0594\u0596\5\30\r\2\u0595") + buf.write("\u0594\3\2\2\2\u0595\u0596\3\2\2\2\u0596\u0598\3\2\2\2") + buf.write("\u0597\u0599\5\20\t\2\u0598\u0597\3\2\2\2\u0598\u0599") + buf.write("\3\2\2\2\u0599a\3\2\2\2\u059a\u059b\7\u00d0\2\2\u059b") + buf.write("\u059c\5\6\4\2\u059cc\3\2\2\2\u059d\u059e\7\u009e\2\2") + buf.write("\u059e\u059f\7N\2\2\u059f\u05a4\5\u00c0a\2\u05a0\u05a1") + buf.write("\7\23\2\2\u05a1\u05a3\5\u00c0a\2\u05a2\u05a0\3\2\2\2\u05a3") + buf.write("\u05a6\3\2\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a5\3\2\2\2") + buf.write("\u05a5e\3\2\2\2\u05a6\u05a4\3\2\2\2\u05a7\u05a8\7M\2\2") + buf.write("\u05a8\u05a9\7N\2\2\u05a9\u05ae\5h\65\2\u05aa\u05ab\7") + buf.write("\23\2\2\u05ab\u05ad\5h\65\2\u05ac\u05aa\3\2\2\2\u05ad") + buf.write("\u05b0\3\2\2\2\u05ae\u05ac\3\2\2\2\u05ae\u05af\3\2\2\2") + buf.write("\u05afg\3\2\2\2\u05b0\u05ae\3\2\2\2\u05b1\u05b3\5\u00c0") + buf.write("a\2\u05b2\u05b4\t\30\2\2\u05b3\u05b2\3\2\2\2\u05b3\u05b4") + buf.write("\3\2\2\2\u05b4i\3\2\2\2\u05b5\u05b6\7y\2\2\u05b6\u05b9") + buf.write("\7\u00be\2\2\u05b7\u05b9\7\u00a0\2\2\u05b8\u05b5\3\2\2") + buf.write("\2\u05b8\u05b7\3\2\2\2\u05b9\u05ba\3\2\2\2\u05ba\u05bb") + buf.write("\7\65\2\2\u05bb\u05bc\5n8\2\u05bc\u05bd\7\61\2\2\u05bd") + buf.write("\u05be\5n8\2\u05bek\3\2\2\2\u05bf\u05c0\7\u00f3\2\2\u05c0") + buf.write("m\3\2\2\2\u05c1\u05c2\7\u00f3\2\2\u05c2\u05cd\7\u009b") + buf.write("\2\2\u05c3\u05c4\7\u00f3\2\2\u05c4\u05cd\7\u009c\2\2\u05c5") + buf.write("\u05c6\7\u00a1\2\2\u05c6\u05c7\7y\2\2\u05c7\u05cd\7\u00bf") + buf.write("\2\2\u05c8\u05c9\7\u009d\2\2\u05c9\u05cd\7\u009b\2\2\u05ca") + buf.write("\u05cb\7\u009d\2\2\u05cb\u05cd\7\u009c\2\2\u05cc\u05c1") + buf.write("\3\2\2\2\u05cc\u05c3\3\2\2\2\u05cc\u05c5\3\2\2\2\u05cc") + buf.write("\u05c8\3\2\2\2\u05cc\u05ca\3\2\2\2\u05cdo\3\2\2\2\u05ce") + buf.write("\u05cf\7\u0092\2\2\u05cf\u05d0\t\31\2\2\u05d0\u05d5\5") + buf.write("\u00c0a\2\u05d1\u05d2\7\23\2\2\u05d2\u05d4\5\u00c0a\2") + buf.write("\u05d3\u05d1\3\2\2\2\u05d4\u05d7\3\2\2\2\u05d5\u05d3\3") + buf.write("\2\2\2\u05d5\u05d6\3\2\2\2\u05d6\u05dc\3\2\2\2\u05d7\u05d5") + buf.write("\3\2\2\2\u05d8\u05d9\7\u0092\2\2\u05d9\u05da\7J\2\2\u05da") + buf.write("\u05dc\5\b\5\2\u05db\u05ce\3\2\2\2\u05db\u05d8\3\2\2\2") + buf.write("\u05dcq\3\2\2\2\u05dd\u05de\7\u0094\2\2\u05de\u05df\5") + buf.write("\b\5\2\u05dfs\3\2\2\2\u05e0\u05e1\5\u00bc_\2\u05e1\u05e4") + buf.write("\5z>\2\u05e2\u05e3\7\u00df\2\2\u05e3\u05e5\5X-\2\u05e4") + buf.write("\u05e2\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5u\3\2\2\2\u05e6") + buf.write("\u05ea\5~@\2\u05e7\u05ea\5\u0082B\2\u05e8\u05ea\5\u0080") + buf.write("A\2\u05e9\u05e6\3\2\2\2\u05e9\u05e7\3\2\2\2\u05e9\u05e8") + buf.write("\3\2\2\2\u05eaw\3\2\2\2\u05eb\u05ee\5\u0080A\2\u05ec\u05ee") + buf.write("\5~@\2\u05ed\u05eb\3\2\2\2\u05ed\u05ec\3\2\2\2\u05eey") + buf.write("\3\2\2\2\u05ef\u05f5\5~@\2\u05f0\u05f5\5\u0082B\2\u05f1") + buf.write("\u05f5\5\u0086D\2\u05f2\u05f5\5|?\2\u05f3\u05f5\5\u0080") + buf.write("A\2\u05f4\u05ef\3\2\2\2\u05f4\u05f0\3\2\2\2\u05f4\u05f1") + buf.write("\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f3\3\2\2\2\u05f5") + buf.write("{\3\2\2\2\u05f6\u05fa\7\u0081\2\2\u05f7\u05fa\5\u0088") + buf.write("E\2\u05f8\u05fa\5\u008aF\2\u05f9\u05f6\3\2\2\2\u05f9\u05f7") + buf.write("\3\2\2\2\u05f9\u05f8\3\2\2\2\u05fa}\3\2\2\2\u05fb\u05fe") + buf.write("\5\u00dan\2\u05fc\u05fe\5\u008cG\2\u05fd\u05fb\3\2\2\2") + buf.write("\u05fd\u05fc\3\2\2\2\u05fe\u0600\3\2\2\2\u05ff\u0601\5") + buf.write("\u00a6T\2\u0600\u05ff\3\2\2\2\u0600\u0601\3\2\2\2\u0601") + buf.write("\u0606\3\2\2\2\u0602\u0604\7\64\2\2\u0603\u0602\3\2\2") + buf.write("\2\u0603\u0604\3\2\2\2\u0604\u0605\3\2\2\2\u0605\u0607") + buf.write("\78\2\2\u0606\u0603\3\2\2\2\u0606\u0607\3\2\2\2\u0607") + buf.write("\177\3\2\2\2\u0608\u060d\5\u00ceh\2\u0609\u060a\7\n\2") + buf.write("\2\u060a\u060b\5~@\2\u060b\u060c\7\13\2\2\u060c\u060e") + buf.write("\3\2\2\2\u060d\u0609\3\2\2\2\u060d\u060e\3\2\2\2\u060e") + buf.write("\u0081\3\2\2\2\u060f\u061b\7{\2\2\u0610\u0611\7\7\2\2") + buf.write("\u0611\u0616\5\u00a8U\2\u0612\u0613\7\23\2\2\u0613\u0615") + buf.write("\5\u00a8U\2\u0614\u0612\3\2\2\2\u0615\u0618\3\2\2\2\u0616") + buf.write("\u0614\3\2\2\2\u0616\u0617\3\2\2\2\u0617\u0619\3\2\2\2") + buf.write("\u0618\u0616\3\2\2\2\u0619\u061a\7\b\2\2\u061a\u061c\3") + buf.write("\2\2\2\u061b\u0610\3\2\2\2\u061b\u061c\3\2\2\2\u061c\u0083") + buf.write("\3\2\2\2\u061d\u0620\5\u0082B\2\u061e\u0620\5~@\2\u061f") + buf.write("\u061d\3\2\2\2\u061f\u061e\3\2\2\2\u0620\u0085\3\2\2\2") + buf.write("\u0621\u0626\7\u00f1\2\2\u0622\u0623\7\n\2\2\u0623\u0624") + buf.write("\5~@\2\u0624\u0625\7\13\2\2\u0625\u0627\3\2\2\2\u0626") + buf.write("\u0622\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0087\3\2\2\2") + buf.write("\u0628\u0646\7\177\2\2\u0629\u0635\7\u00ed\2\2\u062a\u062b") + buf.write("\7\7\2\2\u062b\u0630\5\u008cG\2\u062c\u062d\7\21\2\2\u062d") + buf.write("\u062f\5\u008cG\2\u062e\u062c\3\2\2\2\u062f\u0632\3\2") + buf.write("\2\2\u0630\u062e\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0633") + buf.write("\3\2\2\2\u0632\u0630\3\2\2\2\u0633\u0634\7\b\2\2\u0634") + buf.write("\u0636\3\2\2\2\u0635\u062a\3\2\2\2\u0635\u0636\3\2\2\2") + buf.write("\u0636\u0646\3\2\2\2\u0637\u0643\7\u00ee\2\2\u0638\u0639") + buf.write("\7\7\2\2\u0639\u063e\5\u00bc_\2\u063a\u063b\7\21\2\2\u063b") + buf.write("\u063d\5\u00bc_\2\u063c\u063a\3\2\2\2\u063d\u0640\3\2") + buf.write("\2\2\u063e\u063c\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0641") + buf.write("\3\2\2\2\u0640\u063e\3\2\2\2\u0641\u0642\7\b\2\2\u0642") + buf.write("\u0644\3\2\2\2\u0643\u0638\3\2\2\2\u0643\u0644\3\2\2\2") + buf.write("\u0644\u0646\3\2\2\2\u0645\u0628\3\2\2\2\u0645\u0629\3") + buf.write("\2\2\2\u0645\u0637\3\2\2\2\u0646\u0089\3\2\2\2\u0647\u0670") + buf.write("\7\u0080\2\2\u0648\u0659\7\u00ef\2\2\u0649\u064a\7\7\2") + buf.write("\2\u064a\u0656\7\u00f7\2\2\u064b\u064c\7\3\2\2\u064c\u0651") + buf.write("\5\u008cG\2\u064d\u064e\7\21\2\2\u064e\u0650\5\u008cG") + buf.write("\2\u064f\u064d\3\2\2\2\u0650\u0653\3\2\2\2\u0651\u064f") + buf.write("\3\2\2\2\u0651\u0652\3\2\2\2\u0652\u0654\3\2\2\2\u0653") + buf.write("\u0651\3\2\2\2\u0654\u0655\7\4\2\2\u0655\u0657\3\2\2\2") + buf.write("\u0656\u064b\3\2\2\2\u0656\u0657\3\2\2\2\u0657\u0658\3") + buf.write("\2\2\2\u0658\u065a\7\b\2\2\u0659\u0649\3\2\2\2\u0659\u065a") + buf.write("\3\2\2\2\u065a\u0670\3\2\2\2\u065b\u066d\7\u00f0\2\2\u065c") + buf.write("\u065d\7\7\2\2\u065d\u0669\5\u00bc_\2\u065e\u065f\7\3") + buf.write("\2\2\u065f\u0664\5\u00bc_\2\u0660\u0661\7\21\2\2\u0661") + buf.write("\u0663\5\u00bc_\2\u0662\u0660\3\2\2\2\u0663\u0666\3\2") + buf.write("\2\2\u0664\u0662\3\2\2\2\u0664\u0665\3\2\2\2\u0665\u0667") + buf.write("\3\2\2\2\u0666\u0664\3\2\2\2\u0667\u0668\7\4\2\2\u0668") + buf.write("\u066a\3\2\2\2\u0669\u065e\3\2\2\2\u0669\u066a\3\2\2\2") + buf.write("\u066a\u066b\3\2\2\2\u066b\u066c\7\b\2\2\u066c\u066e\3") + buf.write("\2\2\2\u066d\u065c\3\2\2\2\u066d\u066e\3\2\2\2\u066e\u0670") + buf.write("\3\2\2\2\u066f\u0647\3\2\2\2\u066f\u0648\3\2\2\2\u066f") + buf.write("\u065b\3\2\2\2\u0670\u008b\3\2\2\2\u0671\u0672\7\u00f7") + buf.write("\2\2\u0672\u008d\3\2\2\2\u0673\u0674\7\u00f7\2\2\u0674") + buf.write("\u008f\3\2\2\2\u0675\u0676\t\32\2\2\u0676\u067b\5\u0092") + buf.write("J\2\u0677\u0678\7\23\2\2\u0678\u067a\5\u0092J\2\u0679") + buf.write("\u0677\3\2\2\2\u067a\u067d\3\2\2\2\u067b\u0679\3\2\2\2") + buf.write("\u067b\u067c\3\2\2\2\u067c\u0091\3\2\2\2\u067d\u067b\3") + buf.write("\2\2\2\u067e\u0681\5\u00bc_\2\u067f\u0680\7\60\2\2\u0680") + buf.write("\u0682\5\u00ba^\2\u0681\u067f\3\2\2\2\u0681\u0682\3\2") + buf.write("\2\2\u0682\u0093\3\2\2\2\u0683\u0688\5\u0096L\2\u0684") + buf.write("\u0685\7\u00f9\2\2\u0685\u0687\5\u0096L\2\u0686\u0684") + buf.write("\3\2\2\2\u0687\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688") + buf.write("\u0689\3\2\2\2\u0689\u0095\3\2\2\2\u068a\u0688\3\2\2\2") + buf.write("\u068b\u068c\7\u00f7\2\2\u068c\u068e\7\25\2\2\u068d\u068b") + buf.write("\3\2\2\2\u068d\u068e\3\2\2\2\u068e\u0693\3\2\2\2\u068f") + buf.write("\u0690\7\u00bb\2\2\u0690\u0691\5\b\5\2\u0691\u0692\7\33") + buf.write("\2\2\u0692\u0694\3\2\2\2\u0693\u068f\3\2\2\2\u0693\u0694") + buf.write("\3\2\2\2\u0694\u0695\3\2\2\2\u0695\u0697\5\b\5\2\u0696") + buf.write("\u0698\5\u00c4c\2\u0697\u0696\3\2\2\2\u0697\u0698\3\2") + buf.write("\2\2\u0698\u069a\3\2\2\2\u0699\u069b\5\u00c6d\2\u069a") + buf.write("\u0699\3\2\2\2\u069a\u069b\3\2\2\2\u069b\u0097\3\2\2\2") + buf.write("\u069c\u06a1\5\u009aN\2\u069d\u069e\7\u00f9\2\2\u069e") + buf.write("\u06a0\5\u009aN\2\u069f\u069d\3\2\2\2\u06a0\u06a3\3\2") + buf.write("\2\2\u06a1\u069f\3\2\2\2\u06a1\u06a2\3\2\2\2\u06a2\u0099") + buf.write("\3\2\2\2\u06a3\u06a1\3\2\2\2\u06a4\u06a5\7\u00f7\2\2\u06a5") + buf.write("\u06a7\7\25\2\2\u06a6\u06a4\3\2\2\2\u06a6\u06a7\3\2\2") + buf.write("\2\u06a7\u06a8\3\2\2\2\u06a8\u06aa\5\u00a0Q\2\u06a9\u06ab") + buf.write("\5\u00c4c\2\u06aa\u06a9\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab") + buf.write("\u06ad\3\2\2\2\u06ac\u06ae\5\u00c6d\2\u06ad\u06ac\3\2") + buf.write("\2\2\u06ad\u06ae\3\2\2\2\u06ae\u009b\3\2\2\2\u06af\u06b2") + buf.write("\t\32\2\2\u06b0\u06b1\7\u00a9\2\2\u06b1\u06b3\5\u009e") + buf.write("P\2\u06b2\u06b0\3\2\2\2\u06b2\u06b3\3\2\2\2\u06b3\u06b4") + buf.write("\3\2\2\2\u06b4\u06b5\7\u0082\2\2\u06b5\u06b6\7\u00f7\2") + buf.write("\2\u06b6\u009d\3\2\2\2\u06b7\u06bc\5\u0092J\2\u06b8\u06b9") + buf.write("\7\23\2\2\u06b9\u06bb\5\u0092J\2\u06ba\u06b8\3\2\2\2\u06bb") + buf.write("\u06be\3\2\2\2\u06bc\u06ba\3\2\2\2\u06bc\u06bd\3\2\2\2") + buf.write("\u06bd\u009f\3\2\2\2\u06be\u06bc\3\2\2\2\u06bf\u06c0\7") + buf.write("\u00bb\2\2\u06c0\u06c1\5\b\5\2\u06c1\u06c2\7\33\2\2\u06c2") + buf.write("\u06c4\3\2\2\2\u06c3\u06bf\3\2\2\2\u06c3\u06c4\3\2\2\2") + buf.write("\u06c4\u06c5\3\2\2\2\u06c5\u06c7\5\u00a4S\2\u06c6\u06c8") + buf.write("\5\u00c8e\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8") + buf.write("\u06c9\3\2\2\2\u06c9\u06cd\5\u00a2R\2\u06ca\u06cc\5\u00a2") + buf.write("R\2\u06cb\u06ca\3\2\2\2\u06cc\u06cf\3\2\2\2\u06cd\u06cb") + buf.write("\3\2\2\2\u06cd\u06ce\3\2\2\2\u06ce\u00a1\3\2\2\2\u06cf") + buf.write("\u06cd\3\2\2\2\u06d0\u06d2\t\33\2\2\u06d1\u06d0\3\2\2") + buf.write("\2\u06d1\u06d2\3\2\2\2\u06d2\u06d3\3\2\2\2\u06d3\u06d8") + buf.write("\5\u00a4S\2\u06d4\u06d5\7\5\2\2\u06d5\u06d6\5\b\5\2\u06d6") + buf.write("\u06d7\7\6\2\2\u06d7\u06d9\3\2\2\2\u06d8\u06d4\3\2\2\2") + buf.write("\u06d8\u06d9\3\2\2\2\u06d9\u00a3\3\2\2\2\u06da\u06db\t") + buf.write("\34\2\2\u06db\u00a5\3\2\2\2\u06dc\u06dd\7\5\2\2\u06dd") + buf.write("\u06de\5\b\5\2\u06de\u06df\7\6\2\2\u06df\u06ec\3\2\2\2") + buf.write("\u06e0\u06e1\7\7\2\2\u06e1\u06e6\5X-\2\u06e2\u06e3\7\23") + buf.write("\2\2\u06e3\u06e5\5X-\2\u06e4\u06e2\3\2\2\2\u06e5\u06e8") + buf.write("\3\2\2\2\u06e6\u06e4\3\2\2\2\u06e6\u06e7\3\2\2\2\u06e7") + buf.write("\u06e9\3\2\2\2\u06e8\u06e6\3\2\2\2\u06e9\u06ea\7\b\2\2") + buf.write("\u06ea\u06ec\3\2\2\2\u06eb\u06dc\3\2\2\2\u06eb\u06e0\3") + buf.write("\2\2\2\u06ec\u00a7\3\2\2\2\u06ed\u06f0\5\u0080A\2\u06ee") + buf.write("\u06f1\5\u00c0a\2\u06ef\u06f1\5\u00aaV\2\u06f0\u06ee\3") + buf.write("\2\2\2\u06f0\u06ef\3\2\2\2\u06f1\u00a9\3\2\2\2\u06f2\u06f4") + buf.write("\7u\2\2\u06f3\u06f5\t\35\2\2\u06f4\u06f3\3\2\2\2\u06f4") + buf.write("\u06f5\3\2\2\2\u06f5\u00ab\3\2\2\2\u06f6\u06f7\t\36\2") + buf.write("\2\u06f7\u00ad\3\2\2\2\u06f8\u06f9\t\37\2\2\u06f9\u00af") + buf.write("\3\2\2\2\u06fa\u06fb\7\u00a9\2\2\u06fb\u0700\5\u00c0a") + buf.write("\2\u06fc\u06fd\7\23\2\2\u06fd\u06ff\5\u00c0a\2\u06fe\u06fc") + buf.write("\3\2\2\2\u06ff\u0702\3\2\2\2\u0700\u06fe\3\2\2\2\u0700") + buf.write("\u0701\3\2\2\2\u0701\u00b1\3\2\2\2\u0702\u0700\3\2\2\2") + buf.write("\u0703\u0704\t \2\2\u0704\u00b3\3\2\2\2\u0705\u0706\7") + buf.write("H\2\2\u0706\u0707\5\6\4\2\u0707\u00b5\3\2\2\2\u0708\u0709") + buf.write('\t!\2\2\u0709\u00b7\3\2\2\2\u070a\u070b\t"\2\2\u070b') + buf.write("\u00b9\3\2\2\2\u070c\u070d\7\u00f7\2\2\u070d\u00bb\3\2") + buf.write("\2\2\u070e\u070f\7\u00f7\2\2\u070f\u00bd\3\2\2\2\u0710") + buf.write("\u0711\7\u00f7\2\2\u0711\u00bf\3\2\2\2\u0712\u0715\7\u00f7") + buf.write("\2\2\u0713\u0714\7\27\2\2\u0714\u0716\7\u00f7\2\2\u0715") + buf.write("\u0713\3\2\2\2\u0715\u0716\3\2\2\2\u0716\u00c1\3\2\2\2") + buf.write("\u0717\u0718\7\7\2\2\u0718\u071d\5X-\2\u0719\u071a\7\23") + buf.write("\2\2\u071a\u071c\5X-\2\u071b\u0719\3\2\2\2\u071c\u071f") + buf.write("\3\2\2\2\u071d\u071b\3\2\2\2\u071d\u071e\3\2\2\2\u071e") + buf.write("\u0720\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0721\7\b\2\2") + buf.write("\u0721\u00c3\3\2\2\2\u0722\u0723\7I\2\2\u0723\u0724\5") + buf.write("\u00d8m\2\u0724\u00c5\3\2\2\2\u0725\u0726\7L\2\2\u0726") + buf.write("\u0727\5\u00d8m\2\u0727\u00c7\3\2\2\2\u0728\u0729\t#\2") + buf.write("\2\u0729\u00c9\3\2\2\2\u072a\u072d\5\6\4\2\u072b\u072d") + buf.write("\7u\2\2\u072c\u072a\3\2\2\2\u072c\u072b\3\2\2\2\u072d") + buf.write("\u00cb\3\2\2\2\u072e\u0731\5\b\5\2\u072f\u0731\7u\2\2") + buf.write("\u0730\u072e\3\2\2\2\u0730\u072f\3\2\2\2\u0731\u00cd\3") + buf.write("\2\2\2\u0732\u0738\7j\2\2\u0733\u0738\7\u00ec\2\2\u0734") + buf.write("\u0738\7i\2\2\u0735\u0738\7k\2\2\u0736\u0738\5\u00d0i") + buf.write("\2\u0737\u0732\3\2\2\2\u0737\u0733\3\2\2\2\u0737\u0734") + buf.write("\3\2\2\2\u0737\u0735\3\2\2\2\u0737\u0736\3\2\2\2\u0738") + buf.write("\u00cf\3\2\2\2\u0739\u073a\7p\2\2\u073a\u073b\7k\2\2\u073b") + buf.write("\u00d1\3\2\2\2\u073c\u073d\7\u00f7\2\2\u073d\u00d3\3\2") + buf.write("\2\2\u073e\u073f\7\u00f7\2\2\u073f\u00d5\3\2\2\2\u0740") + buf.write("\u0741\7\u00f7\2\2\u0741\u00d7\3\2\2\2\u0742\u0743\t$") + buf.write("\2\2\u0743\u00d9\3\2\2\2\u0744\u0745\t%\2\2\u0745\u00db") + buf.write("\3\2\2\2\u0746\u0747\t&\2\2\u0747\u00dd\3\2\2\2\u00c6") buf.write("\u00e3\u00f1\u010a\u0111\u012f\u0131\u0133\u014d\u0154") buf.write("\u016a\u016c\u016e\u0179\u0187\u0190\u0198\u019f\u01a1") buf.write("\u01ac\u01b5\u01c7\u01d0\u01df\u01ea\u01ed\u01f2\u0213") @@ -961,15 +970,15 @@ def serializedATN(): buf.write("\u0475\u047f\u0483\u0486\u0489\u048c\u0494\u0497\u049a") buf.write("\u049d\u04a1\u04b9\u04c0\u04c2\u04cc\u04cf\u04d2\u04de") buf.write("\u04e0\u04e5\u04f5\u04fd\u0500\u0503\u050e\u0510\u0515") - buf.write("\u0521\u0531\u053c\u0540\u0547\u0551\u055b\u055f\u0566") - buf.write("\u056e\u0577\u057a\u057f\u0582\u0587\u058a\u058d\u0599") - buf.write("\u05a3\u05a8\u05ad\u05c1\u05ca\u05d0\u05d9\u05de\u05e2") - buf.write("\u05e9\u05ee\u05f2\u05f5\u05f8\u05fb\u0602\u060b\u0610") - buf.write("\u0614\u061b\u0625\u062a\u0633\u0638\u063a\u0646\u064b") - buf.write("\u064e\u0659\u065e\u0662\u0664\u0670\u0676\u067d\u0682") - buf.write("\u0688\u068c\u068f\u0696\u069b\u069f\u06a2\u06a7\u06b1") - buf.write("\u06b8\u06bc\u06c2\u06c6\u06cd\u06db\u06e0\u06e5\u06e9") - buf.write("\u06f5\u070a\u0712\u0721\u0725\u072c") + buf.write("\u0521\u0531\u053c\u0540\u0547\u0551\u055b\u0566\u056a") + buf.write("\u0571\u0579\u0582\u0585\u058a\u058d\u0592\u0595\u0598") + buf.write("\u05a4\u05ae\u05b3\u05b8\u05cc\u05d5\u05db\u05e4\u05e9") + buf.write("\u05ed\u05f4\u05f9\u05fd\u0600\u0603\u0606\u060d\u0616") + buf.write("\u061b\u061f\u0626\u0630\u0635\u063e\u0643\u0645\u0651") + buf.write("\u0656\u0659\u0664\u0669\u066d\u066f\u067b\u0681\u0688") + buf.write("\u068d\u0693\u0697\u069a\u06a1\u06a6\u06aa\u06ad\u06b2") + buf.write("\u06bc\u06c3\u06c7\u06cd\u06d1\u06d8\u06e6\u06eb\u06f0") + buf.write("\u06f4\u0700\u0715\u071d\u072c\u0730\u0737") return buf.getvalue() @@ -1963,6 +1972,7 @@ class Parser(ANTLRParser): def __init__(self, input: TokenStream, output: TextIO = sys.stdout): super().__init__(input, output) + self.checkVersion("4.9.3") self._interp = ParserATNSimulator( self, self.atn, self.decisionsToDFA, self.sharedContextCache ) @@ -2001,7 +2011,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitStart"): listener.exitStart(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStart"): + return visitor.visitStart(self) + else: + return visitor.visitChildren(self) + def start(self) -> Any: + localctx = Parser.StartContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_start) self._la = 0 # Token type @@ -2060,6 +2077,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDefineExpression"): listener.exitDefineExpression(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefineExpression"): + return visitor.visitDefineExpression(self) + else: + return visitor.visitChildren(self) + class TemporaryAssignmentContext(StatementContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -2084,6 +2107,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitTemporaryAssignment"): listener.exitTemporaryAssignment(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTemporaryAssignment"): + return visitor.visitTemporaryAssignment(self) + else: + return visitor.visitChildren(self) + class PersistAssignmentContext(StatementContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -2108,7 +2137,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitPersistAssignment"): listener.exitPersistAssignment(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPersistAssignment"): + return visitor.visitPersistAssignment(self) + else: + return visitor.visitChildren(self) + def statement(self): + localctx = Parser.StatementContext(self, self._ctx, self.state) self.enterRule(localctx, 2, self.RULE_statement) try: @@ -2181,6 +2217,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitVarIdExpr"): listener.exitVarIdExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVarIdExpr"): + return visitor.visitVarIdExpr(self) + else: + return visitor.visitChildren(self) + class MembershipExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2203,6 +2245,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitMembershipExpr"): listener.exitMembershipExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMembershipExpr"): + return visitor.visitMembershipExpr(self) + else: + return visitor.visitChildren(self) + class InNotInExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2233,6 +2281,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitInNotInExpr"): listener.exitInNotInExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInNotInExpr"): + return visitor.visitInNotInExpr(self) + else: + return visitor.visitChildren(self) + class BooleanExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2264,6 +2318,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitBooleanExpr"): listener.exitBooleanExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanExpr"): + return visitor.visitBooleanExpr(self) + else: + return visitor.visitChildren(self) + class ComparisonExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2289,6 +2349,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComparisonExpr"): listener.exitComparisonExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonExpr"): + return visitor.visitComparisonExpr(self) + else: + return visitor.visitChildren(self) + class UnaryExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2316,6 +2382,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryExpr"): listener.exitUnaryExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryExpr"): + return visitor.visitUnaryExpr(self) + else: + return visitor.visitChildren(self) + class FunctionsExpressionContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2332,6 +2404,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitFunctionsExpression"): listener.exitFunctionsExpression(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunctionsExpression"): + return visitor.visitFunctionsExpression(self) + else: + return visitor.visitChildren(self) + class IfExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2363,6 +2441,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitIfExpr"): listener.exitIfExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIfExpr"): + return visitor.visitIfExpr(self) + else: + return visitor.visitChildren(self) + class ClauseExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2390,6 +2474,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitClauseExpr"): listener.exitClauseExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitClauseExpr"): + return visitor.visitClauseExpr(self) + else: + return visitor.visitChildren(self) + class CaseExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2427,6 +2517,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCaseExpr"): listener.exitCaseExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCaseExpr"): + return visitor.visitCaseExpr(self) + else: + return visitor.visitChildren(self) + class ArithmeticExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2455,6 +2551,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitArithmeticExpr"): listener.exitArithmeticExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExpr"): + return visitor.visitArithmeticExpr(self) + else: + return visitor.visitChildren(self) + class ParenthesisExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2477,6 +2579,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitParenthesisExpr"): listener.exitParenthesisExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParenthesisExpr"): + return visitor.visitParenthesisExpr(self) + else: + return visitor.visitChildren(self) + class ConstantExprContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2493,6 +2601,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitConstantExpr"): listener.exitConstantExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConstantExpr"): + return visitor.visitConstantExpr(self) + else: + return visitor.visitChildren(self) + class ArithmeticExprOrConcatContext(ExprContext): def __init__(self, ANTLRParser, ctx: ParserRuleContext): # actually a Parser.ExprContext super().__init__(ANTLRParser) @@ -2524,6 +2638,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitArithmeticExprOrConcat"): listener.exitArithmeticExprOrConcat(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExprOrConcat"): + return visitor.visitArithmeticExprOrConcat(self) + else: + return visitor.visitChildren(self) + def expr(self, _p: int = 0): _parentctx = self._ctx _parentState = self.state @@ -2884,6 +3004,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitArithmeticExprComp"): listener.exitArithmeticExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExprComp"): + return visitor.visitArithmeticExprComp(self) + else: + return visitor.visitChildren(self) + class IfExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -2917,6 +3043,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitIfExprComp"): listener.exitIfExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIfExprComp"): + return visitor.visitIfExprComp(self) + else: + return visitor.visitChildren(self) + class ComparisonExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -2943,6 +3075,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComparisonExprComp"): listener.exitComparisonExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonExprComp"): + return visitor.visitComparisonExprComp(self) + else: + return visitor.visitChildren(self) + class FunctionsExpressionCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -2961,6 +3099,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitFunctionsExpressionComp"): listener.exitFunctionsExpressionComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunctionsExpressionComp"): + return visitor.visitFunctionsExpressionComp(self) + else: + return visitor.visitChildren(self) + class CompIdContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -2979,6 +3123,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCompId"): listener.exitCompId(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCompId"): + return visitor.visitCompId(self) + else: + return visitor.visitChildren(self) + class ConstantExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -2997,6 +3147,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitConstantExprComp"): listener.exitConstantExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConstantExprComp"): + return visitor.visitConstantExprComp(self) + else: + return visitor.visitChildren(self) + class ArithmeticExprOrConcatCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3030,6 +3186,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitArithmeticExprOrConcatComp"): listener.exitArithmeticExprOrConcatComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArithmeticExprOrConcatComp"): + return visitor.visitArithmeticExprOrConcatComp(self) + else: + return visitor.visitChildren(self) + class ParenthesisExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3054,6 +3216,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitParenthesisExprComp"): listener.exitParenthesisExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParenthesisExprComp"): + return visitor.visitParenthesisExprComp(self) + else: + return visitor.visitChildren(self) + class InNotInExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3086,6 +3254,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitInNotInExprComp"): listener.exitInNotInExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInNotInExprComp"): + return visitor.visitInNotInExprComp(self) + else: + return visitor.visitChildren(self) + class UnaryExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3115,6 +3289,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryExprComp"): listener.exitUnaryExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryExprComp"): + return visitor.visitUnaryExprComp(self) + else: + return visitor.visitChildren(self) + class CaseExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3154,6 +3334,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCaseExprComp"): listener.exitCaseExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCaseExprComp"): + return visitor.visitCaseExprComp(self) + else: + return visitor.visitChildren(self) + class BooleanExprCompContext(ExprComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3187,6 +3373,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitBooleanExprComp"): listener.exitBooleanExprComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanExprComp"): + return visitor.visitBooleanExprComp(self) + else: + return visitor.visitChildren(self) + def exprComponent(self, _p: int = 0): _parentctx = self._ctx _parentState = self.state @@ -3500,6 +3692,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitNumericFunctionsComponents"): listener.exitNumericFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNumericFunctionsComponents"): + return visitor.visitNumericFunctionsComponents(self) + else: + return visitor.visitChildren(self) + class StringFunctionsComponentsContext(FunctionsComponentsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3518,6 +3716,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitStringFunctionsComponents"): listener.exitStringFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringFunctionsComponents"): + return visitor.visitStringFunctionsComponents(self) + else: + return visitor.visitChildren(self) + class ComparisonFunctionsComponentsContext(FunctionsComponentsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3536,6 +3740,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComparisonFunctionsComponents"): listener.exitComparisonFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonFunctionsComponents"): + return visitor.visitComparisonFunctionsComponents(self) + else: + return visitor.visitChildren(self) + class TimeFunctionsComponentsContext(FunctionsComponentsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3554,6 +3764,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitTimeFunctionsComponents"): listener.exitTimeFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeFunctionsComponents"): + return visitor.visitTimeFunctionsComponents(self) + else: + return visitor.visitChildren(self) + class GenericFunctionsComponentsContext(FunctionsComponentsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3572,6 +3788,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitGenericFunctionsComponents"): listener.exitGenericFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericFunctionsComponents"): + return visitor.visitGenericFunctionsComponents(self) + else: + return visitor.visitChildren(self) + class AnalyticFunctionsComponentsContext(FunctionsComponentsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3590,6 +3812,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAnalyticFunctionsComponents"): listener.exitAnalyticFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnalyticFunctionsComponents"): + return visitor.visitAnalyticFunctionsComponents(self) + else: + return visitor.visitChildren(self) + class ConditionalFunctionsComponentsContext(FunctionsComponentsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3608,6 +3836,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitConditionalFunctionsComponents"): listener.exitConditionalFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionalFunctionsComponents"): + return visitor.visitConditionalFunctionsComponents(self) + else: + return visitor.visitChildren(self) + class AggregateFunctionsComponentsContext(FunctionsComponentsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3626,7 +3860,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAggregateFunctionsComponents"): listener.exitAggregateFunctionsComponents(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggregateFunctionsComponents"): + return visitor.visitAggregateFunctionsComponents(self) + else: + return visitor.visitChildren(self) + def functionsComponents(self): + localctx = Parser.FunctionsComponentsContext(self, self._ctx, self.state) self.enterRule(localctx, 8, self.RULE_functionsComponents) try: @@ -3728,6 +3969,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitHierarchyFunctions"): listener.exitHierarchyFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHierarchyFunctions"): + return visitor.visitHierarchyFunctions(self) + else: + return visitor.visitChildren(self) + class StringFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3746,6 +3993,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitStringFunctions"): listener.exitStringFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringFunctions"): + return visitor.visitStringFunctions(self) + else: + return visitor.visitChildren(self) + class ValidationFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3764,6 +4017,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValidationFunctions"): listener.exitValidationFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationFunctions"): + return visitor.visitValidationFunctions(self) + else: + return visitor.visitChildren(self) + class GenericFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3782,6 +4041,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitGenericFunctions"): listener.exitGenericFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGenericFunctions"): + return visitor.visitGenericFunctions(self) + else: + return visitor.visitChildren(self) + class ConditionalFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3800,6 +4065,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitConditionalFunctions"): listener.exitConditionalFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionalFunctions"): + return visitor.visitConditionalFunctions(self) + else: + return visitor.visitChildren(self) + class AggregateFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3818,6 +4089,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAggregateFunctions"): listener.exitAggregateFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggregateFunctions"): + return visitor.visitAggregateFunctions(self) + else: + return visitor.visitChildren(self) + class JoinFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3836,6 +4113,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitJoinFunctions"): listener.exitJoinFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinFunctions"): + return visitor.visitJoinFunctions(self) + else: + return visitor.visitChildren(self) + class ComparisonFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3854,6 +4137,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComparisonFunctions"): listener.exitComparisonFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonFunctions"): + return visitor.visitComparisonFunctions(self) + else: + return visitor.visitChildren(self) + class NumericFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3872,6 +4161,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitNumericFunctions"): listener.exitNumericFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNumericFunctions"): + return visitor.visitNumericFunctions(self) + else: + return visitor.visitChildren(self) + class TimeFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3890,6 +4185,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitTimeFunctions"): listener.exitTimeFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeFunctions"): + return visitor.visitTimeFunctions(self) + else: + return visitor.visitChildren(self) + class SetFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3908,6 +4209,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSetFunctions"): listener.exitSetFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSetFunctions"): + return visitor.visitSetFunctions(self) + else: + return visitor.visitChildren(self) + class AnalyticFunctionsContext(FunctionsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -3926,7 +4233,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAnalyticFunctions"): listener.exitAnalyticFunctions(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnalyticFunctions"): + return visitor.visitAnalyticFunctions(self) + else: + return visitor.visitChildren(self) + def functions(self): + localctx = Parser.FunctionsContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_functions) try: @@ -4064,7 +4378,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDatasetClause"): listener.exitDatasetClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDatasetClause"): + return visitor.visitDatasetClause(self) + else: + return visitor.visitChildren(self) + def datasetClause(self): + localctx = Parser.DatasetClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_datasetClause) try: @@ -4150,7 +4471,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRenameClause"): listener.exitRenameClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRenameClause"): + return visitor.visitRenameClause(self) + else: + return visitor.visitChildren(self) + def renameClause(self): + localctx = Parser.RenameClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_renameClause) self._la = 0 # Token type @@ -4210,7 +4538,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAggrClause"): listener.exitAggrClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrClause"): + return visitor.visitAggrClause(self) + else: + return visitor.visitChildren(self) + def aggrClause(self): + localctx = Parser.AggrClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 16, self.RULE_aggrClause) self._la = 0 # Token type @@ -4265,7 +4600,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitFilterClause"): listener.exitFilterClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFilterClause"): + return visitor.visitFilterClause(self) + else: + return visitor.visitChildren(self) + def filterClause(self): + localctx = Parser.FilterClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 18, self.RULE_filterClause) try: @@ -4315,7 +4657,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCalcClause"): listener.exitCalcClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCalcClause"): + return visitor.visitCalcClause(self) + else: + return visitor.visitChildren(self) + def calcClause(self): + localctx = Parser.CalcClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_calcClause) self._la = 0 # Token type @@ -4382,7 +4731,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitKeepOrDropClause"): listener.exitKeepOrDropClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitKeepOrDropClause"): + return visitor.visitKeepOrDropClause(self) + else: + return visitor.visitChildren(self) + def keepOrDropClause(self): + localctx = Parser.KeepOrDropClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 22, self.RULE_keepOrDropClause) self._la = 0 # Token type @@ -4454,7 +4810,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitPivotOrUnpivotClause"): listener.exitPivotOrUnpivotClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPivotOrUnpivotClause"): + return visitor.visitPivotOrUnpivotClause(self) + else: + return visitor.visitChildren(self) + def pivotOrUnpivotClause(self): + localctx = Parser.PivotOrUnpivotClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 24, self.RULE_pivotOrUnpivotClause) self._la = 0 # Token type @@ -4526,7 +4889,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCustomPivotClause"): listener.exitCustomPivotClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCustomPivotClause"): + return visitor.visitCustomPivotClause(self) + else: + return visitor.visitChildren(self) + def customPivotClause(self): + localctx = Parser.CustomPivotClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 26, self.RULE_customPivotClause) self._la = 0 # Token type @@ -4597,7 +4967,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSubspaceClause"): listener.exitSubspaceClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubspaceClause"): + return visitor.visitSubspaceClause(self) + else: + return visitor.visitChildren(self) + def subspaceClause(self): + localctx = Parser.SubspaceClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 28, self.RULE_subspaceClause) self._la = 0 # Token type @@ -4683,7 +5060,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitJoinExpr"): listener.exitJoinExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinExpr"): + return visitor.visitJoinExpr(self) + else: + return visitor.visitChildren(self) + def joinOperators(self): + localctx = Parser.JoinOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 30, self.RULE_joinOperators) self._la = 0 # Token type @@ -4815,6 +5199,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDefOperator"): listener.exitDefOperator(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefOperator"): + return visitor.visitDefOperator(self) + else: + return visitor.visitChildren(self) + class DefHierarchicalContext(DefOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -4866,6 +5256,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDefHierarchical"): listener.exitDefHierarchical(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefHierarchical"): + return visitor.visitDefHierarchical(self) + else: + return visitor.visitChildren(self) + class DefDatapointRulesetContext(DefOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -4917,7 +5313,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDefDatapointRuleset"): listener.exitDefDatapointRuleset(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDefDatapointRuleset"): + return visitor.visitDefDatapointRuleset(self) + else: + return visitor.visitChildren(self) + def defOperators(self): + localctx = Parser.DefOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 32, self.RULE_defOperators) self._la = 0 # Token type @@ -5118,6 +5521,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitEvalAtom"): listener.exitEvalAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitEvalAtom"): + return visitor.visitEvalAtom(self) + else: + return visitor.visitChildren(self) + class CastExprDatasetContext(GenericOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -5160,6 +5569,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCastExprDataset"): listener.exitCastExprDataset(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCastExprDataset"): + return visitor.visitCastExprDataset(self) + else: + return visitor.visitChildren(self) + class CallDatasetContext(GenericOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -5196,7 +5611,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCallDataset"): listener.exitCallDataset(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCallDataset"): + return visitor.visitCallDataset(self) + else: + return visitor.visitChildren(self) + def genericOperators(self): + localctx = Parser.GenericOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 34, self.RULE_genericOperators) self._la = 0 # Token type @@ -5575,6 +5997,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitEvalAtomComponent"): listener.exitEvalAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitEvalAtomComponent"): + return visitor.visitEvalAtomComponent(self) + else: + return visitor.visitChildren(self) + class CastExprComponentContext(GenericOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -5617,6 +6045,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCastExprComponent"): listener.exitCastExprComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCastExprComponent"): + return visitor.visitCastExprComponent(self) + else: + return visitor.visitChildren(self) + class CallComponentContext(GenericOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -5653,7 +6087,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCallComponent"): listener.exitCallComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCallComponent"): + return visitor.visitCallComponent(self) + else: + return visitor.visitChildren(self) + def genericOperatorsComponent(self): + localctx = Parser.GenericOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 36, self.RULE_genericOperatorsComponent) self._la = 0 # Token type @@ -5968,7 +6409,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitParameterComponent"): listener.exitParameterComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameterComponent"): + return visitor.visitParameterComponent(self) + else: + return visitor.visitChildren(self) + def parameterComponent(self): + localctx = Parser.ParameterComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 38, self.RULE_parameterComponent) try: @@ -6093,7 +6541,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitParameter"): listener.exitParameter(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameter"): + return visitor.visitParameter(self) + else: + return visitor.visitChildren(self) + def parameter(self): + localctx = Parser.ParameterContext(self, self._ctx, self.state) self.enterRule(localctx, 40, self.RULE_parameter) try: @@ -6264,6 +6719,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitInstrAtom"): listener.exitInstrAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInstrAtom"): + return visitor.visitInstrAtom(self) + else: + return visitor.visitChildren(self) + class UnaryStringFunctionContext(StringOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -6307,6 +6768,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryStringFunction"): listener.exitUnaryStringFunction(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryStringFunction"): + return visitor.visitUnaryStringFunction(self) + else: + return visitor.visitChildren(self) + class SubstrAtomContext(StringOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -6348,6 +6815,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSubstrAtom"): listener.exitSubstrAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubstrAtom"): + return visitor.visitSubstrAtom(self) + else: + return visitor.visitChildren(self) + class ReplaceAtomContext(StringOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -6388,7 +6861,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitReplaceAtom"): listener.exitReplaceAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitReplaceAtom"): + return visitor.visitReplaceAtom(self) + else: + return visitor.visitChildren(self) + def stringOperators(self): + localctx = Parser.StringOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 42, self.RULE_stringOperators) self._la = 0 # Token type @@ -6597,6 +7077,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitReplaceAtomComponent"): listener.exitReplaceAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitReplaceAtomComponent"): + return visitor.visitReplaceAtomComponent(self) + else: + return visitor.visitChildren(self) + class UnaryStringFunctionComponentContext(StringOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -6640,6 +7126,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryStringFunctionComponent"): listener.exitUnaryStringFunctionComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryStringFunctionComponent"): + return visitor.visitUnaryStringFunctionComponent(self) + else: + return visitor.visitChildren(self) + class SubstrAtomComponentContext(StringOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -6681,6 +7173,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSubstrAtomComponent"): listener.exitSubstrAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubstrAtomComponent"): + return visitor.visitSubstrAtomComponent(self) + else: + return visitor.visitChildren(self) + class InstrAtomComponentContext(StringOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -6726,7 +7224,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitInstrAtomComponent"): listener.exitInstrAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInstrAtomComponent"): + return visitor.visitInstrAtomComponent(self) + else: + return visitor.visitChildren(self) + def stringOperatorsComponent(self): + localctx = Parser.StringOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 44, self.RULE_stringOperatorsComponent) self._la = 0 # Token type @@ -6938,6 +7443,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryNumeric"): listener.exitUnaryNumeric(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryNumeric"): + return visitor.visitUnaryNumeric(self) + else: + return visitor.visitChildren(self) + class UnaryWithOptionalNumericContext(NumericOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -6975,6 +7486,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryWithOptionalNumeric"): listener.exitUnaryWithOptionalNumeric(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryWithOptionalNumeric"): + return visitor.visitUnaryWithOptionalNumeric(self) + else: + return visitor.visitChildren(self) + class BinaryNumericContext(NumericOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7020,7 +7537,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitBinaryNumeric"): listener.exitBinaryNumeric(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBinaryNumeric"): + return visitor.visitBinaryNumeric(self) + else: + return visitor.visitChildren(self) + def numericOperators(self): + localctx = Parser.NumericOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 46, self.RULE_numericOperators) self._la = 0 # Token type @@ -7188,6 +7712,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryNumericComponent"): listener.exitUnaryNumericComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryNumericComponent"): + return visitor.visitUnaryNumericComponent(self) + else: + return visitor.visitChildren(self) + class BinaryNumericComponentContext(NumericOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7233,6 +7763,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitBinaryNumericComponent"): listener.exitBinaryNumericComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBinaryNumericComponent"): + return visitor.visitBinaryNumericComponent(self) + else: + return visitor.visitChildren(self) + class UnaryWithOptionalNumericComponentContext(NumericOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7270,7 +7806,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnaryWithOptionalNumericComponent"): listener.exitUnaryWithOptionalNumericComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnaryWithOptionalNumericComponent"): + return visitor.visitUnaryWithOptionalNumericComponent(self) + else: + return visitor.visitChildren(self) + def numericOperatorsComponent(self): + localctx = Parser.NumericOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 48, self.RULE_numericOperatorsComponent) self._la = 0 # Token type @@ -7434,6 +7977,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitBetweenAtom"): listener.exitBetweenAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBetweenAtom"): + return visitor.visitBetweenAtom(self) + else: + return visitor.visitChildren(self) + class CharsetMatchAtomContext(ComparisonOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7469,6 +8018,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCharsetMatchAtom"): listener.exitCharsetMatchAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCharsetMatchAtom"): + return visitor.visitCharsetMatchAtom(self) + else: + return visitor.visitChildren(self) + class IsNullAtomContext(ComparisonOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7496,6 +8051,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitIsNullAtom"): listener.exitIsNullAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIsNullAtom"): + return visitor.visitIsNullAtom(self) + else: + return visitor.visitChildren(self) + class ExistInAtomContext(ComparisonOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7537,7 +8098,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitExistInAtom"): listener.exitExistInAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitExistInAtom"): + return visitor.visitExistInAtom(self) + else: + return visitor.visitChildren(self) + def comparisonOperators(self): + localctx = Parser.ComparisonOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 50, self.RULE_comparisonOperators) self._la = 0 # Token type @@ -7669,6 +8237,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitIsNullAtomComponent"): listener.exitIsNullAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIsNullAtomComponent"): + return visitor.visitIsNullAtomComponent(self) + else: + return visitor.visitChildren(self) + class CharsetMatchAtomComponentContext(ComparisonOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7704,6 +8278,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCharsetMatchAtomComponent"): listener.exitCharsetMatchAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCharsetMatchAtomComponent"): + return visitor.visitCharsetMatchAtomComponent(self) + else: + return visitor.visitChildren(self) + class BetweenAtomComponentContext(ComparisonOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7743,7 +8323,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitBetweenAtomComponent"): listener.exitBetweenAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBetweenAtomComponent"): + return visitor.visitBetweenAtomComponent(self) + else: + return visitor.visitChildren(self) + def comparisonOperatorsComponent(self): + localctx = Parser.ComparisonOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 52, self.RULE_comparisonOperatorsComponent) try: @@ -7849,6 +8436,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayToYearAtom"): listener.exitDayToYearAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToYearAtom"): + return visitor.visitDayToYearAtom(self) + else: + return visitor.visitChildren(self) + class YearAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7876,6 +8469,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitYearAtom"): listener.exitYearAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearAtom"): + return visitor.visitYearAtom(self) + else: + return visitor.visitChildren(self) + class MonthToDayAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7903,6 +8502,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitMonthToDayAtom"): listener.exitMonthToDayAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthToDayAtom"): + return visitor.visitMonthToDayAtom(self) + else: + return visitor.visitChildren(self) + class DayToMonthAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7930,6 +8535,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayToMonthAtom"): listener.exitDayToMonthAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToMonthAtom"): + return visitor.visitDayToMonthAtom(self) + else: + return visitor.visitChildren(self) + class PeriodAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7957,6 +8568,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitPeriodAtom"): listener.exitPeriodAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeriodAtom"): + return visitor.visitPeriodAtom(self) + else: + return visitor.visitChildren(self) + class FillTimeAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -7993,6 +8610,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitFillTimeAtom"): listener.exitFillTimeAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFillTimeAtom"): + return visitor.visitFillTimeAtom(self) + else: + return visitor.visitChildren(self) + class MonthAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8020,6 +8643,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitMonthAtom"): listener.exitMonthAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthAtom"): + return visitor.visitMonthAtom(self) + else: + return visitor.visitChildren(self) + class DayOfYearAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8047,6 +8676,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayOfYearAtom"): listener.exitDayOfYearAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfYearAtom"): + return visitor.visitDayOfYearAtom(self) + else: + return visitor.visitChildren(self) + class FlowAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8078,6 +8713,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitFlowAtom"): listener.exitFlowAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFlowAtom"): + return visitor.visitFlowAtom(self) + else: + return visitor.visitChildren(self) + class TimeShiftAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8111,6 +8752,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitTimeShiftAtom"): listener.exitTimeShiftAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeShiftAtom"): + return visitor.visitTimeShiftAtom(self) + else: + return visitor.visitChildren(self) + class TimeAggAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8162,6 +8809,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitTimeAggAtom"): listener.exitTimeAggAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeAggAtom"): + return visitor.visitTimeAggAtom(self) + else: + return visitor.visitChildren(self) + class DateDiffAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8197,6 +8850,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDateDiffAtom"): listener.exitDateDiffAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateDiffAtom"): + return visitor.visitDateDiffAtom(self) + else: + return visitor.visitChildren(self) + class DateAddAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8236,6 +8895,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDateAddAtom"): listener.exitDateAddAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateAddAtom"): + return visitor.visitDateAddAtom(self) + else: + return visitor.visitChildren(self) + class YearToDayAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8263,6 +8928,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitYearToDayAtom"): listener.exitYearToDayAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearToDayAtom"): + return visitor.visitYearToDayAtom(self) + else: + return visitor.visitChildren(self) + class DayOfMonthAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8290,6 +8961,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayOfMonthAtom"): listener.exitDayOfMonthAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfMonthAtom"): + return visitor.visitDayOfMonthAtom(self) + else: + return visitor.visitChildren(self) + class CurrentDateAtomContext(TimeOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8314,7 +8991,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCurrentDateAtom"): listener.exitCurrentDateAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCurrentDateAtom"): + return visitor.visitCurrentDateAtom(self) + else: + return visitor.visitChildren(self) + def timeOperators(self): + localctx = Parser.TimeOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 54, self.RULE_timeOperators) self._la = 0 # Token type @@ -8763,6 +9447,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitPeriodAtomComponent"): listener.exitPeriodAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPeriodAtomComponent"): + return visitor.visitPeriodAtomComponent(self) + else: + return visitor.visitChildren(self) + class TimeShiftAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8796,6 +9486,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitTimeShiftAtomComponent"): listener.exitTimeShiftAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeShiftAtomComponent"): + return visitor.visitTimeShiftAtomComponent(self) + else: + return visitor.visitChildren(self) + class TimeAggAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8847,6 +9543,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitTimeAggAtomComponent"): listener.exitTimeAggAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeAggAtomComponent"): + return visitor.visitTimeAggAtomComponent(self) + else: + return visitor.visitChildren(self) + class DayToMonthAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8874,6 +9576,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayToMonthAtomComponent"): listener.exitDayToMonthAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToMonthAtomComponent"): + return visitor.visitDayToMonthAtomComponent(self) + else: + return visitor.visitChildren(self) + class DateAddAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8913,6 +9621,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDateAddAtomComponent"): listener.exitDateAddAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateAddAtomComponent"): + return visitor.visitDateAddAtomComponent(self) + else: + return visitor.visitChildren(self) + class MonthToDayAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8940,6 +9654,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitMonthToDayAtomComponent"): listener.exitMonthToDayAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthToDayAtomComponent"): + return visitor.visitMonthToDayAtomComponent(self) + else: + return visitor.visitChildren(self) + class DayOfMonthAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -8967,7 +9687,13 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayOfMonthAtomComponent"): listener.exitDayOfMonthAtomComponent(self) - class DayOfYearAtomComponentContext(TimeOperatorsComponentContext): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfMonthAtomComponent"): + return visitor.visitDayOfMonthAtomComponent(self) + else: + return visitor.visitChildren(self) + + class DayOfYearAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext ): # actually a Parser.TimeOperatorsComponentContext @@ -8994,6 +9720,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayOfYearAtomComponent"): listener.exitDayOfYearAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayOfYearAtomComponent"): + return visitor.visitDayOfYearAtomComponent(self) + else: + return visitor.visitChildren(self) + class MonthAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9021,6 +9753,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitMonthAtomComponent"): listener.exitMonthAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMonthAtomComponent"): + return visitor.visitMonthAtomComponent(self) + else: + return visitor.visitChildren(self) + class YearToDayAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9048,6 +9786,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitYearToDayAtomComponent"): listener.exitYearToDayAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearToDayAtomComponent"): + return visitor.visitYearToDayAtomComponent(self) + else: + return visitor.visitChildren(self) + class FillTimeAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9084,6 +9828,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitFillTimeAtomComponent"): listener.exitFillTimeAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFillTimeAtomComponent"): + return visitor.visitFillTimeAtomComponent(self) + else: + return visitor.visitChildren(self) + class DayToYearAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9111,6 +9861,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDayToYearAtomComponent"): listener.exitDayToYearAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDayToYearAtomComponent"): + return visitor.visitDayToYearAtomComponent(self) + else: + return visitor.visitChildren(self) + class CurrentDateAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9135,6 +9891,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCurrentDateAtomComponent"): listener.exitCurrentDateAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCurrentDateAtomComponent"): + return visitor.visitCurrentDateAtomComponent(self) + else: + return visitor.visitChildren(self) + class FlowAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9166,6 +9928,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitFlowAtomComponent"): listener.exitFlowAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFlowAtomComponent"): + return visitor.visitFlowAtomComponent(self) + else: + return visitor.visitChildren(self) + class DateDiffAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9201,6 +9969,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDateDiffAtomComponent"): listener.exitDateDiffAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateDiffAtomComponent"): + return visitor.visitDateDiffAtomComponent(self) + else: + return visitor.visitChildren(self) + class YearAtomComponentContext(TimeOperatorsComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9228,7 +10002,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitYearAtomComponent"): listener.exitYearAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitYearAtomComponent"): + return visitor.visitYearAtomComponent(self) + else: + return visitor.visitChildren(self) + def timeOperatorsComponent(self): + localctx = Parser.TimeOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 56, self.RULE_timeOperatorsComponent) self._la = 0 # Token type @@ -9677,6 +10458,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSetOrSYmDiffAtom"): listener.exitSetOrSYmDiffAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSetOrSYmDiffAtom"): + return visitor.visitSetOrSYmDiffAtom(self) + else: + return visitor.visitChildren(self) + class IntersectAtomContext(SetOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9714,6 +10501,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitIntersectAtom"): listener.exitIntersectAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntersectAtom"): + return visitor.visitIntersectAtom(self) + else: + return visitor.visitChildren(self) + class UnionAtomContext(SetOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -9751,7 +10544,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitUnionAtom"): listener.exitUnionAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUnionAtom"): + return visitor.visitUnionAtom(self) + else: + return visitor.visitChildren(self) + def setOperators(self): + localctx = Parser.SetOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 58, self.RULE_setOperators) self._la = 0 # Token type @@ -9901,7 +10701,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitHierarchyOperators"): listener.exitHierarchyOperators(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHierarchyOperators"): + return visitor.visitHierarchyOperators(self) + else: + return visitor.visitChildren(self) + def hierarchyOperators(self): + localctx = Parser.HierarchyOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 60, self.RULE_hierarchyOperators) self._la = 0 # Token type @@ -10040,6 +10847,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValidateHRruleset"): listener.exitValidateHRruleset(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidateHRruleset"): + return visitor.visitValidateHRruleset(self) + else: + return visitor.visitChildren(self) + class ValidateDPrulesetContext(ValidationOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -10090,6 +10903,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValidateDPruleset"): listener.exitValidateDPruleset(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidateDPruleset"): + return visitor.visitValidateDPruleset(self) + else: + return visitor.visitChildren(self) + class ValidationSimpleContext(ValidationOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -10136,7 +10955,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValidationSimple"): listener.exitValidationSimple(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationSimple"): + return visitor.visitValidationSimple(self) + else: + return visitor.visitChildren(self) + def validationOperators(self): + localctx = Parser.ValidationOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 62, self.RULE_validationOperators) self._la = 0 # Token type @@ -10355,7 +11181,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitNvlAtom"): listener.exitNvlAtom(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNvlAtom"): + return visitor.visitNvlAtom(self) + else: + return visitor.visitChildren(self) + def conditionalOperators(self): + localctx = Parser.ConditionalOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 64, self.RULE_conditionalOperators) try: @@ -10429,7 +11262,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitNvlAtomComponent"): listener.exitNvlAtomComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNvlAtomComponent"): + return visitor.visitNvlAtomComponent(self) + else: + return visitor.visitChildren(self) + def conditionalOperatorsComponent(self): + localctx = Parser.ConditionalOperatorsComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 66, self.RULE_conditionalOperatorsComponent) try: @@ -10523,6 +11363,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAggrComp"): listener.exitAggrComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrComp"): + return visitor.visitAggrComp(self) + else: + return visitor.visitChildren(self) + class CountAggrCompContext(AggrOperatorsContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -10547,7 +11393,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCountAggrComp"): listener.exitCountAggrComp(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCountAggrComp"): + return visitor.visitCountAggrComp(self) + else: + return visitor.visitChildren(self) + def aggrOperators(self): + localctx = Parser.AggrOperatorsContext(self, self._ctx, self.state) self.enterRule(localctx, 68, self.RULE_aggrOperators) self._la = 0 # Token type @@ -10685,7 +11538,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAggrDataset"): listener.exitAggrDataset(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrDataset"): + return visitor.visitAggrDataset(self) + else: + return visitor.visitChildren(self) + def aggrOperatorsGrouping(self): + localctx = Parser.AggrOperatorsGroupingContext(self, self._ctx, self.state) self.enterRule(localctx, 70, self.RULE_aggrOperatorsGrouping) self._la = 0 # Token type @@ -10820,6 +11680,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitLagOrLeadAn"): listener.exitLagOrLeadAn(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLagOrLeadAn"): + return visitor.visitLagOrLeadAn(self) + else: + return visitor.visitChildren(self) + class RatioToReportAnContext(AnFunctionContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -10861,6 +11727,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRatioToReportAn"): listener.exitRatioToReportAn(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRatioToReportAn"): + return visitor.visitRatioToReportAn(self) + else: + return visitor.visitChildren(self) + class AnSimpleFunctionContext(AnFunctionContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -10943,7 +11815,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAnSimpleFunction"): listener.exitAnSimpleFunction(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnSimpleFunction"): + return visitor.visitAnSimpleFunction(self) + else: + return visitor.visitChildren(self) + def anFunction(self): + localctx = Parser.AnFunctionContext(self, self._ctx, self.state) self.enterRule(localctx, 72, self.RULE_anFunction) self._la = 0 # Token type @@ -11210,6 +12089,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAnSimpleFunctionComponent"): listener.exitAnSimpleFunctionComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAnSimpleFunctionComponent"): + return visitor.visitAnSimpleFunctionComponent(self) + else: + return visitor.visitChildren(self) + class LagOrLeadAnComponentContext(AnFunctionComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -11269,6 +12154,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitLagOrLeadAnComponent"): listener.exitLagOrLeadAnComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLagOrLeadAnComponent"): + return visitor.visitLagOrLeadAnComponent(self) + else: + return visitor.visitChildren(self) + class RankAnComponentContext(AnFunctionComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -11311,6 +12202,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRankAnComponent"): listener.exitRankAnComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRankAnComponent"): + return visitor.visitRankAnComponent(self) + else: + return visitor.visitChildren(self) + class RatioToReportAnComponentContext(AnFunctionComponentContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -11352,7 +12249,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRatioToReportAnComponent"): listener.exitRatioToReportAnComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRatioToReportAnComponent"): + return visitor.visitRatioToReportAnComponent(self) + else: + return visitor.visitChildren(self) + def anFunctionComponent(self): + localctx = Parser.AnFunctionComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 74, self.RULE_anFunctionComponent) self._la = 0 # Token type @@ -11590,7 +12494,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRenameClauseItem"): listener.exitRenameClauseItem(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRenameClauseItem"): + return visitor.visitRenameClauseItem(self) + else: + return visitor.visitChildren(self) + def renameClauseItem(self): + localctx = Parser.RenameClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 76, self.RULE_renameClauseItem) try: @@ -11639,7 +12550,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAggregateClause"): listener.exitAggregateClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggregateClause"): + return visitor.visitAggregateClause(self) + else: + return visitor.visitChildren(self) + def aggregateClause(self): + localctx = Parser.AggregateClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 78, self.RULE_aggregateClause) self._la = 0 # Token type @@ -11697,7 +12615,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAggrFunctionClause"): listener.exitAggrFunctionClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAggrFunctionClause"): + return visitor.visitAggrFunctionClause(self) + else: + return visitor.visitChildren(self) + def aggrFunctionClause(self): + localctx = Parser.AggrFunctionClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_aggrFunctionClause) self._la = 0 # Token type @@ -11766,7 +12691,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCalcClauseItem"): listener.exitCalcClauseItem(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCalcClauseItem"): + return visitor.visitCalcClauseItem(self) + else: + return visitor.visitChildren(self) + def calcClauseItem(self): + localctx = Parser.CalcClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 82, self.RULE_calcClauseItem) self._la = 0 # Token type @@ -11835,7 +12767,14 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSubspaceClauseItem"): listener.exitSubspaceClauseItem(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubspaceClauseItem"): + return visitor.visitSubspaceClauseItem(self) + else: + return visitor.visitChildren(self) + def subspaceClauseItem(self): + localctx = Parser.SubspaceClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 84, self.RULE_subspaceClauseItem) try: @@ -11925,6 +12864,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitScalarWithCast"): listener.exitScalarWithCast(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarWithCast"): + return visitor.visitScalarWithCast(self) + else: + return visitor.visitChildren(self) + class SimpleScalarContext(ScalarItemContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -11943,27 +12888,74 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSimpleScalar"): listener.exitSimpleScalar(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSimpleScalar"): + return visitor.visitSimpleScalar(self) + else: + return visitor.visitChildren(self) + + class ScalarVarWithCastContext(ScalarItemContext): + def __init__( + self, ANTLRParser, ctx: ParserRuleContext + ): # actually a Parser.ScalarItemContext + super().__init__(ANTLRParser) + self.copyFrom(ctx) + + def CAST(self): + return self.getToken(Parser.CAST, 0) + + def LPAREN(self): + return self.getToken(Parser.LPAREN, 0) + + def varID(self): + return self.getTypedRuleContext(Parser.VarIDContext, 0) + + def COMMA(self, i: int = None): + if i is None: + return self.getTokens(Parser.COMMA) + else: + return self.getToken(Parser.COMMA, i) + + def RPAREN(self): + return self.getToken(Parser.RPAREN, 0) + + def basicScalarType(self): + return self.getTypedRuleContext(Parser.BasicScalarTypeContext, 0) + + def STRING_CONSTANT(self): + return self.getToken(Parser.STRING_CONSTANT, 0) + + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterScalarVarWithCast"): + listener.enterScalarVarWithCast(self) + + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitScalarVarWithCast"): + listener.exitScalarVarWithCast(self) + + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarVarWithCast"): + return visitor.visitScalarVarWithCast(self) + else: + return visitor.visitChildren(self) + def scalarItem(self): + localctx = Parser.ScalarItemContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_scalarItem) self._la = 0 # Token type try: - self.state = 1373 + self.state = 1384 self._errHandler.sync(self) - token = self._input.LA(1) - if token in [ - Parser.NULL_CONSTANT, - Parser.INTEGER_CONSTANT, - Parser.NUMBER_CONSTANT, - Parser.BOOLEAN_CONSTANT, - Parser.STRING_CONSTANT, - ]: + la_ = self._interp.adaptivePredict(self._input, 125, self._ctx) + if la_ == 1: localctx = Parser.SimpleScalarContext(self, localctx) self.enterOuterAlt(localctx, 1) self.state = 1361 self.constant() pass - elif token in [Parser.CAST]: + + elif la_ == 2: localctx = Parser.ScalarWithCastContext(self, localctx) self.enterOuterAlt(localctx, 2) self.state = 1362 @@ -11989,8 +12981,33 @@ def scalarItem(self): self.state = 1371 self.match(Parser.RPAREN) pass - else: - raise NoViableAltException(self) + + elif la_ == 3: + localctx = Parser.ScalarVarWithCastContext(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 1373 + self.match(Parser.CAST) + self.state = 1374 + self.match(Parser.LPAREN) + self.state = 1375 + self.varID() + self.state = 1376 + self.match(Parser.COMMA) + + self.state = 1377 + self.basicScalarType() + self.state = 1380 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la == Parser.COMMA: + self.state = 1378 + self.match(Parser.COMMA) + self.state = 1379 + self.match(Parser.STRING_CONSTANT) + + self.state = 1382 + self.match(Parser.RPAREN) + pass except RecognitionException as re: localctx.exception = re @@ -12030,23 +13047,30 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitJoinClauseWithoutUsing"): listener.exitJoinClauseWithoutUsing(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinClauseWithoutUsing"): + return visitor.visitJoinClauseWithoutUsing(self) + else: + return visitor.visitChildren(self) + def joinClauseWithoutUsing(self): + localctx = Parser.JoinClauseWithoutUsingContext(self, self._ctx, self.state) self.enterRule(localctx, 88, self.RULE_joinClauseWithoutUsing) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1375 + self.state = 1386 self.joinClauseItem() - self.state = 1380 + self.state = 1391 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1376 + self.state = 1387 self.match(Parser.COMMA) - self.state = 1377 + self.state = 1388 self.joinClauseItem() - self.state = 1382 + self.state = 1393 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12097,43 +13121,50 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitJoinClause"): listener.exitJoinClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinClause"): + return visitor.visitJoinClause(self) + else: + return visitor.visitChildren(self) + def joinClause(self): + localctx = Parser.JoinClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 90, self.RULE_joinClause) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1383 + self.state = 1394 self.joinClauseItem() - self.state = 1388 + self.state = 1399 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1384 + self.state = 1395 self.match(Parser.COMMA) - self.state = 1385 + self.state = 1396 self.joinClauseItem() - self.state = 1390 + self.state = 1401 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1400 + self.state = 1411 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.USING: - self.state = 1391 + self.state = 1402 self.match(Parser.USING) - self.state = 1392 + self.state = 1403 self.componentID() - self.state = 1397 + self.state = 1408 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1393 + self.state = 1404 self.match(Parser.COMMA) - self.state = 1394 + self.state = 1405 self.componentID() - self.state = 1399 + self.state = 1410 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12172,21 +13203,28 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitJoinClauseItem"): listener.exitJoinClauseItem(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinClauseItem"): + return visitor.visitJoinClauseItem(self) + else: + return visitor.visitChildren(self) + def joinClauseItem(self): + localctx = Parser.JoinClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 92, self.RULE_joinClauseItem) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1402 + self.state = 1413 self.expr(0) - self.state = 1405 + self.state = 1416 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.AS: - self.state = 1403 + self.state = 1414 self.match(Parser.AS) - self.state = 1404 + self.state = 1415 self.alias() except RecognitionException as re: @@ -12233,50 +13271,57 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitJoinBody"): listener.exitJoinBody(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinBody"): + return visitor.visitJoinBody(self) + else: + return visitor.visitChildren(self) + def joinBody(self): + localctx = Parser.JoinBodyContext(self, self._ctx, self.state) self.enterRule(localctx, 94, self.RULE_joinBody) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1408 + self.state = 1419 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.FILTER: - self.state = 1407 + self.state = 1418 self.filterClause() - self.state = 1413 + self.state = 1424 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.CALC]: - self.state = 1410 + self.state = 1421 self.calcClause() pass elif token in [Parser.APPLY]: - self.state = 1411 + self.state = 1422 self.joinApplyClause() pass elif token in [Parser.AGGREGATE]: - self.state = 1412 + self.state = 1423 self.aggrClause() pass elif token in [Parser.RPAREN, Parser.DROP, Parser.KEEP, Parser.RENAME]: pass else: pass - self.state = 1416 + self.state = 1427 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.DROP or _la == Parser.KEEP: - self.state = 1415 + self.state = 1426 self.keepOrDropClause() - self.state = 1419 + self.state = 1430 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.RENAME: - self.state = 1418 + self.state = 1429 self.renameClause() except RecognitionException as re: @@ -12311,14 +13356,21 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitJoinApplyClause"): listener.exitJoinApplyClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitJoinApplyClause"): + return visitor.visitJoinApplyClause(self) + else: + return visitor.visitChildren(self) + def joinApplyClause(self): + localctx = Parser.JoinApplyClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 96, self.RULE_joinApplyClause) try: self.enterOuterAlt(localctx, 1) - self.state = 1421 + self.state = 1432 self.match(Parser.APPLY) - self.state = 1422 + self.state = 1433 self.expr(0) except RecognitionException as re: localctx.exception = re @@ -12364,27 +13416,34 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitPartitionByClause"): listener.exitPartitionByClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPartitionByClause"): + return visitor.visitPartitionByClause(self) + else: + return visitor.visitChildren(self) + def partitionByClause(self): + localctx = Parser.PartitionByClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 98, self.RULE_partitionByClause) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1424 + self.state = 1435 self.match(Parser.PARTITION) - self.state = 1425 + self.state = 1436 self.match(Parser.BY) - self.state = 1426 + self.state = 1437 self.componentID() - self.state = 1431 + self.state = 1442 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1427 + self.state = 1438 self.match(Parser.COMMA) - self.state = 1428 + self.state = 1439 self.componentID() - self.state = 1433 + self.state = 1444 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12432,27 +13491,34 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOrderByClause"): listener.exitOrderByClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOrderByClause"): + return visitor.visitOrderByClause(self) + else: + return visitor.visitChildren(self) + def orderByClause(self): + localctx = Parser.OrderByClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 100, self.RULE_orderByClause) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1434 + self.state = 1445 self.match(Parser.ORDER) - self.state = 1435 + self.state = 1446 self.match(Parser.BY) - self.state = 1436 + self.state = 1447 self.orderByItem() - self.state = 1441 + self.state = 1452 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1437 + self.state = 1448 self.match(Parser.COMMA) - self.state = 1438 + self.state = 1449 self.orderByItem() - self.state = 1443 + self.state = 1454 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12491,19 +13557,26 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOrderByItem"): listener.exitOrderByItem(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOrderByItem"): + return visitor.visitOrderByItem(self) + else: + return visitor.visitChildren(self) + def orderByItem(self): + localctx = Parser.OrderByItemContext(self, self._ctx, self.state) self.enterRule(localctx, 102, self.RULE_orderByItem) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1444 + self.state = 1455 self.componentID() - self.state = 1446 + self.state = 1457 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.ASC or _la == Parser.DESC: - self.state = 1445 + self.state = 1456 _la = self._input.LA(1) if not (_la == Parser.ASC or _la == Parser.DESC): self._errHandler.recoverInline(self) @@ -12560,34 +13633,41 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitWindowingClause"): listener.exitWindowingClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitWindowingClause"): + return visitor.visitWindowingClause(self) + else: + return visitor.visitChildren(self) + def windowingClause(self): + localctx = Parser.WindowingClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 104, self.RULE_windowingClause) try: self.enterOuterAlt(localctx, 1) - self.state = 1451 + self.state = 1462 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.DATA]: - self.state = 1448 + self.state = 1459 self.match(Parser.DATA) - self.state = 1449 + self.state = 1460 self.match(Parser.POINTS) pass elif token in [Parser.RANGE]: - self.state = 1450 + self.state = 1461 self.match(Parser.RANGE) pass else: raise NoViableAltException(self) - self.state = 1453 + self.state = 1464 self.match(Parser.BETWEEN) - self.state = 1454 + self.state = 1465 localctx.from_ = self.limitClauseItem() - self.state = 1455 + self.state = 1466 self.match(Parser.AND) - self.state = 1456 + self.state = 1467 localctx.to_ = self.limitClauseItem() except RecognitionException as re: localctx.exception = re @@ -12618,12 +13698,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSignedInteger"): listener.exitSignedInteger(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSignedInteger"): + return visitor.visitSignedInteger(self) + else: + return visitor.visitChildren(self) + def signedInteger(self): + localctx = Parser.SignedIntegerContext(self, self._ctx, self.state) self.enterRule(localctx, 106, self.RULE_signedInteger) try: self.enterOuterAlt(localctx, 1) - self.state = 1458 + self.state = 1469 self.match(Parser.INTEGER_CONSTANT) except RecognitionException as re: localctx.exception = re @@ -12672,52 +13759,59 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitLimitClauseItem"): listener.exitLimitClauseItem(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLimitClauseItem"): + return visitor.visitLimitClauseItem(self) + else: + return visitor.visitChildren(self) + def limitClauseItem(self): + localctx = Parser.LimitClauseItemContext(self, self._ctx, self.state) self.enterRule(localctx, 108, self.RULE_limitClauseItem) try: - self.state = 1471 + self.state = 1482 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 138, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 139, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) - self.state = 1460 + self.state = 1471 self.match(Parser.INTEGER_CONSTANT) - self.state = 1461 + self.state = 1472 self.match(Parser.PRECEDING) pass elif la_ == 2: self.enterOuterAlt(localctx, 2) - self.state = 1462 + self.state = 1473 self.match(Parser.INTEGER_CONSTANT) - self.state = 1463 + self.state = 1474 self.match(Parser.FOLLOWING) pass elif la_ == 3: self.enterOuterAlt(localctx, 3) - self.state = 1464 + self.state = 1475 self.match(Parser.CURRENT) - self.state = 1465 + self.state = 1476 self.match(Parser.DATA) - self.state = 1466 + self.state = 1477 self.match(Parser.POINT) pass elif la_ == 4: self.enterOuterAlt(localctx, 4) - self.state = 1467 + self.state = 1478 self.match(Parser.UNBOUNDED) - self.state = 1468 + self.state = 1479 self.match(Parser.PRECEDING) pass elif la_ == 5: self.enterOuterAlt(localctx, 5) - self.state = 1469 + self.state = 1480 self.match(Parser.UNBOUNDED) - self.state = 1470 + self.state = 1481 self.match(Parser.FOLLOWING) pass @@ -12766,6 +13860,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitGroupAll"): listener.exitGroupAll(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGroupAll"): + return visitor.visitGroupAll(self) + else: + return visitor.visitChildren(self) + class GroupByOrExceptContext(GroupingClauseContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -12803,20 +13903,27 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitGroupByOrExcept"): listener.exitGroupByOrExcept(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitGroupByOrExcept"): + return visitor.visitGroupByOrExcept(self) + else: + return visitor.visitChildren(self) + def groupingClause(self): + localctx = Parser.GroupingClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 110, self.RULE_groupingClause) self._la = 0 # Token type try: - self.state = 1486 + self.state = 1497 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 140, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 141, self._ctx) if la_ == 1: localctx = Parser.GroupByOrExceptContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1473 + self.state = 1484 self.match(Parser.GROUP) - self.state = 1474 + self.state = 1485 localctx.op = self._input.LT(1) _la = self._input.LA(1) if not (_la == Parser.BY or _la == Parser.EXCEPT): @@ -12824,17 +13931,17 @@ def groupingClause(self): else: self._errHandler.reportMatch(self) self.consume() - self.state = 1475 + self.state = 1486 self.componentID() - self.state = 1480 + self.state = 1491 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1476 + self.state = 1487 self.match(Parser.COMMA) - self.state = 1477 + self.state = 1488 self.componentID() - self.state = 1482 + self.state = 1493 self._errHandler.sync(self) _la = self._input.LA(1) @@ -12843,11 +13950,11 @@ def groupingClause(self): elif la_ == 2: localctx = Parser.GroupAllContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1483 + self.state = 1494 self.match(Parser.GROUP) - self.state = 1484 + self.state = 1495 self.match(Parser.ALL) - self.state = 1485 + self.state = 1496 self.exprComponent(0) pass @@ -12883,14 +13990,21 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitHavingClause"): listener.exitHavingClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHavingClause"): + return visitor.visitHavingClause(self) + else: + return visitor.visitChildren(self) + def havingClause(self): + localctx = Parser.HavingClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 112, self.RULE_havingClause) try: self.enterOuterAlt(localctx, 1) - self.state = 1488 + self.state = 1499 self.match(Parser.HAVING) - self.state = 1489 + self.state = 1500 self.exprComponent(0) except RecognitionException as re: localctx.exception = re @@ -12930,23 +14044,30 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitParameterItem"): listener.exitParameterItem(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameterItem"): + return visitor.visitParameterItem(self) + else: + return visitor.visitChildren(self) + def parameterItem(self): + localctx = Parser.ParameterItemContext(self, self._ctx, self.state) self.enterRule(localctx, 114, self.RULE_parameterItem) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1491 + self.state = 1502 self.varID() - self.state = 1492 + self.state = 1503 self.inputParameterType() - self.state = 1495 + self.state = 1506 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.DEFAULT: - self.state = 1493 + self.state = 1504 self.match(Parser.DEFAULT) - self.state = 1494 + self.state = 1505 self.scalarItem() except RecognitionException as re: @@ -12984,11 +14105,18 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOutputParameterType"): listener.exitOutputParameterType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOutputParameterType"): + return visitor.visitOutputParameterType(self) + else: + return visitor.visitChildren(self) + def outputParameterType(self): + localctx = Parser.OutputParameterTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 116, self.RULE_outputParameterType) try: - self.state = 1500 + self.state = 1511 self._errHandler.sync(self) token = self._input.LA(1) if token in [ @@ -13004,12 +14132,12 @@ def outputParameterType(self): Parser.IDENTIFIER, ]: self.enterOuterAlt(localctx, 1) - self.state = 1497 + self.state = 1508 self.scalarType() pass elif token in [Parser.DATASET]: self.enterOuterAlt(localctx, 2) - self.state = 1498 + self.state = 1509 self.datasetType() pass elif token in [ @@ -13020,7 +14148,7 @@ def outputParameterType(self): Parser.COMPONENT, ]: self.enterOuterAlt(localctx, 3) - self.state = 1499 + self.state = 1510 self.componentType() pass else: @@ -13058,11 +14186,18 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOutputParameterTypeComponent"): listener.exitOutputParameterTypeComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOutputParameterTypeComponent"): + return visitor.visitOutputParameterTypeComponent(self) + else: + return visitor.visitChildren(self) + def outputParameterTypeComponent(self): + localctx = Parser.OutputParameterTypeComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 118, self.RULE_outputParameterTypeComponent) try: - self.state = 1504 + self.state = 1515 self._errHandler.sync(self) token = self._input.LA(1) if token in [ @@ -13073,7 +14208,7 @@ def outputParameterTypeComponent(self): Parser.COMPONENT, ]: self.enterOuterAlt(localctx, 1) - self.state = 1502 + self.state = 1513 self.componentType() pass elif token in [ @@ -13089,7 +14224,7 @@ def outputParameterTypeComponent(self): Parser.IDENTIFIER, ]: self.enterOuterAlt(localctx, 2) - self.state = 1503 + self.state = 1514 self.scalarType() pass else: @@ -13136,11 +14271,18 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitInputParameterType"): listener.exitInputParameterType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInputParameterType"): + return visitor.visitInputParameterType(self) + else: + return visitor.visitChildren(self) + def inputParameterType(self): + localctx = Parser.InputParameterTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 120, self.RULE_inputParameterType) try: - self.state = 1511 + self.state = 1522 self._errHandler.sync(self) token = self._input.LA(1) if token in [ @@ -13156,17 +14298,17 @@ def inputParameterType(self): Parser.IDENTIFIER, ]: self.enterOuterAlt(localctx, 1) - self.state = 1506 + self.state = 1517 self.scalarType() pass elif token in [Parser.DATASET]: self.enterOuterAlt(localctx, 2) - self.state = 1507 + self.state = 1518 self.datasetType() pass elif token in [Parser.SET]: self.enterOuterAlt(localctx, 3) - self.state = 1508 + self.state = 1519 self.scalarSetType() pass elif token in [ @@ -13179,7 +14321,7 @@ def inputParameterType(self): Parser.HIERARCHICAL_ON_VAR, ]: self.enterOuterAlt(localctx, 4) - self.state = 1509 + self.state = 1520 self.rulesetType() pass elif token in [ @@ -13190,7 +14332,7 @@ def inputParameterType(self): Parser.COMPONENT, ]: self.enterOuterAlt(localctx, 5) - self.state = 1510 + self.state = 1521 self.componentType() pass else: @@ -13231,21 +14373,28 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRulesetType"): listener.exitRulesetType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRulesetType"): + return visitor.visitRulesetType(self) + else: + return visitor.visitChildren(self) + def rulesetType(self): + localctx = Parser.RulesetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 122, self.RULE_rulesetType) try: - self.state = 1516 + self.state = 1527 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.RULESET]: self.enterOuterAlt(localctx, 1) - self.state = 1513 + self.state = 1524 self.match(Parser.RULESET) pass elif token in [Parser.DATAPOINT, Parser.DATAPOINT_ON_VD, Parser.DATAPOINT_ON_VAR]: self.enterOuterAlt(localctx, 2) - self.state = 1514 + self.state = 1525 self.dpRuleset() pass elif token in [ @@ -13254,7 +14403,7 @@ def rulesetType(self): Parser.HIERARCHICAL_ON_VAR, ]: self.enterOuterAlt(localctx, 3) - self.state = 1515 + self.state = 1526 self.hrRuleset() pass else: @@ -13301,13 +14450,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitScalarType"): listener.exitScalarType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarType"): + return visitor.visitScalarType(self) + else: + return visitor.visitChildren(self) + def scalarType(self): + localctx = Parser.ScalarTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 124, self.RULE_scalarType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1520 + self.state = 1531 self._errHandler.sync(self) token = self._input.LA(1) if token in [ @@ -13321,35 +14477,35 @@ def scalarType(self): Parser.DURATION, Parser.SCALAR, ]: - self.state = 1518 + self.state = 1529 self.basicScalarType() pass elif token in [Parser.IDENTIFIER]: - self.state = 1519 + self.state = 1530 self.valueDomainName() pass else: raise NoViableAltException(self) - self.state = 1523 + self.state = 1534 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.QLPAREN or _la == Parser.GLPAREN: - self.state = 1522 + self.state = 1533 self.scalarTypeConstraint() - self.state = 1529 + self.state = 1540 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.NOT or _la == Parser.NULL_CONSTANT: - self.state = 1526 + self.state = 1537 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.NOT: - self.state = 1525 + self.state = 1536 self.match(Parser.NOT) - self.state = 1528 + self.state = 1539 self.match(Parser.NULL_CONSTANT) except RecognitionException as re: @@ -13390,23 +14546,30 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComponentType"): listener.exitComponentType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComponentType"): + return visitor.visitComponentType(self) + else: + return visitor.visitChildren(self) + def componentType(self): + localctx = Parser.ComponentTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 126, self.RULE_componentType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1531 + self.state = 1542 self.componentRole() - self.state = 1536 + self.state = 1547 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.LT: - self.state = 1532 + self.state = 1543 self.match(Parser.LT) - self.state = 1533 + self.state = 1544 self.scalarType() - self.state = 1534 + self.state = 1545 self.match(Parser.MT) except RecognitionException as re: @@ -13456,35 +14619,42 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDatasetType"): listener.exitDatasetType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDatasetType"): + return visitor.visitDatasetType(self) + else: + return visitor.visitChildren(self) + def datasetType(self): + localctx = Parser.DatasetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 128, self.RULE_datasetType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1538 + self.state = 1549 self.match(Parser.DATASET) - self.state = 1550 + self.state = 1561 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.GLPAREN: - self.state = 1539 + self.state = 1550 self.match(Parser.GLPAREN) - self.state = 1540 + self.state = 1551 self.compConstraint() - self.state = 1545 + self.state = 1556 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1541 + self.state = 1552 self.match(Parser.COMMA) - self.state = 1542 + self.state = 1553 self.compConstraint() - self.state = 1547 + self.state = 1558 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1548 + self.state = 1559 self.match(Parser.GRPAREN) except RecognitionException as re: @@ -13519,16 +14689,23 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitEvalDatasetType"): listener.exitEvalDatasetType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitEvalDatasetType"): + return visitor.visitEvalDatasetType(self) + else: + return visitor.visitChildren(self) + def evalDatasetType(self): + localctx = Parser.EvalDatasetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 130, self.RULE_evalDatasetType) try: - self.state = 1554 + self.state = 1565 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.DATASET]: self.enterOuterAlt(localctx, 1) - self.state = 1552 + self.state = 1563 self.datasetType() pass elif token in [ @@ -13544,7 +14721,7 @@ def evalDatasetType(self): Parser.IDENTIFIER, ]: self.enterOuterAlt(localctx, 2) - self.state = 1553 + self.state = 1564 self.scalarType() pass else: @@ -13588,23 +14765,30 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitScalarSetType"): listener.exitScalarSetType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitScalarSetType"): + return visitor.visitScalarSetType(self) + else: + return visitor.visitChildren(self) + def scalarSetType(self): + localctx = Parser.ScalarSetTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 132, self.RULE_scalarSetType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1556 + self.state = 1567 self.match(Parser.SET) - self.state = 1561 + self.state = 1572 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.LT: - self.state = 1557 + self.state = 1568 self.match(Parser.LT) - self.state = 1558 + self.state = 1569 self.scalarType() - self.state = 1559 + self.state = 1570 self.match(Parser.MT) except RecognitionException as re: @@ -13664,6 +14848,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDataPointVd"): listener.exitDataPointVd(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDataPointVd"): + return visitor.visitDataPointVd(self) + else: + return visitor.visitChildren(self) + class DataPointVarContext(DpRulesetContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -13700,6 +14890,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDataPointVar"): listener.exitDataPointVar(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDataPointVar"): + return visitor.visitDataPointVar(self) + else: + return visitor.visitChildren(self) + class DataPointContext(DpRulesetContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -13718,75 +14914,82 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitDataPoint"): listener.exitDataPoint(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDataPoint"): + return visitor.visitDataPoint(self) + else: + return visitor.visitChildren(self) + def dpRuleset(self): + localctx = Parser.DpRulesetContext(self, self._ctx, self.state) self.enterRule(localctx, 134, self.RULE_dpRuleset) self._la = 0 # Token type try: - self.state = 1592 + self.state = 1603 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.DATAPOINT]: localctx = Parser.DataPointContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1563 + self.state = 1574 self.match(Parser.DATAPOINT) pass elif token in [Parser.DATAPOINT_ON_VD]: localctx = Parser.DataPointVdContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1564 + self.state = 1575 self.match(Parser.DATAPOINT_ON_VD) - self.state = 1576 + self.state = 1587 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.GLPAREN: - self.state = 1565 + self.state = 1576 self.match(Parser.GLPAREN) - self.state = 1566 + self.state = 1577 self.valueDomainName() - self.state = 1571 + self.state = 1582 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.MUL: - self.state = 1567 + self.state = 1578 self.match(Parser.MUL) - self.state = 1568 + self.state = 1579 self.valueDomainName() - self.state = 1573 + self.state = 1584 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1574 + self.state = 1585 self.match(Parser.GRPAREN) pass elif token in [Parser.DATAPOINT_ON_VAR]: localctx = Parser.DataPointVarContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 1578 + self.state = 1589 self.match(Parser.DATAPOINT_ON_VAR) - self.state = 1590 + self.state = 1601 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.GLPAREN: - self.state = 1579 + self.state = 1590 self.match(Parser.GLPAREN) - self.state = 1580 + self.state = 1591 self.varID() - self.state = 1585 + self.state = 1596 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.MUL: - self.state = 1581 + self.state = 1592 self.match(Parser.MUL) - self.state = 1582 + self.state = 1593 self.varID() - self.state = 1587 + self.state = 1598 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1588 + self.state = 1599 self.match(Parser.GRPAREN) pass @@ -13860,6 +15063,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitHrRulesetVdType"): listener.exitHrRulesetVdType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHrRulesetVdType"): + return visitor.visitHrRulesetVdType(self) + else: + return visitor.visitChildren(self) + class HrRulesetVarTypeContext(HrRulesetContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -13903,6 +15112,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitHrRulesetVarType"): listener.exitHrRulesetVarType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHrRulesetVarType"): + return visitor.visitHrRulesetVarType(self) + else: + return visitor.visitChildren(self) + class HrRulesetTypeContext(HrRulesetContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -13921,97 +15136,104 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitHrRulesetType"): listener.exitHrRulesetType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHrRulesetType"): + return visitor.visitHrRulesetType(self) + else: + return visitor.visitChildren(self) + def hrRuleset(self): + localctx = Parser.HrRulesetContext(self, self._ctx, self.state) self.enterRule(localctx, 136, self.RULE_hrRuleset) self._la = 0 # Token type try: - self.state = 1634 + self.state = 1645 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.HIERARCHICAL]: localctx = Parser.HrRulesetTypeContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1594 + self.state = 1605 self.match(Parser.HIERARCHICAL) pass elif token in [Parser.HIERARCHICAL_ON_VD]: localctx = Parser.HrRulesetVdTypeContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1595 + self.state = 1606 self.match(Parser.HIERARCHICAL_ON_VD) - self.state = 1612 + self.state = 1623 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.GLPAREN: - self.state = 1596 + self.state = 1607 self.match(Parser.GLPAREN) - self.state = 1597 + self.state = 1608 localctx.vdName = self.match(Parser.IDENTIFIER) - self.state = 1609 + self.state = 1620 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.LPAREN: - self.state = 1598 + self.state = 1609 self.match(Parser.LPAREN) - self.state = 1599 + self.state = 1610 self.valueDomainName() - self.state = 1604 + self.state = 1615 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.MUL: - self.state = 1600 + self.state = 1611 self.match(Parser.MUL) - self.state = 1601 + self.state = 1612 self.valueDomainName() - self.state = 1606 + self.state = 1617 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1607 + self.state = 1618 self.match(Parser.RPAREN) - self.state = 1611 + self.state = 1622 self.match(Parser.GRPAREN) pass elif token in [Parser.HIERARCHICAL_ON_VAR]: localctx = Parser.HrRulesetVarTypeContext(self, localctx) self.enterOuterAlt(localctx, 3) - self.state = 1614 + self.state = 1625 self.match(Parser.HIERARCHICAL_ON_VAR) - self.state = 1632 + self.state = 1643 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.GLPAREN: - self.state = 1615 + self.state = 1626 self.match(Parser.GLPAREN) - self.state = 1616 + self.state = 1627 localctx.varName = self.varID() - self.state = 1628 + self.state = 1639 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.LPAREN: - self.state = 1617 + self.state = 1628 self.match(Parser.LPAREN) - self.state = 1618 + self.state = 1629 self.varID() - self.state = 1623 + self.state = 1634 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.MUL: - self.state = 1619 + self.state = 1630 self.match(Parser.MUL) - self.state = 1620 + self.state = 1631 self.varID() - self.state = 1625 + self.state = 1636 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1626 + self.state = 1637 self.match(Parser.RPAREN) - self.state = 1630 + self.state = 1641 self.match(Parser.GRPAREN) pass @@ -14047,12 +15269,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValueDomainName"): listener.exitValueDomainName(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainName"): + return visitor.visitValueDomainName(self) + else: + return visitor.visitChildren(self) + def valueDomainName(self): + localctx = Parser.ValueDomainNameContext(self, self._ctx, self.state) self.enterRule(localctx, 138, self.RULE_valueDomainName) try: self.enterOuterAlt(localctx, 1) - self.state = 1636 + self.state = 1647 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -14083,12 +15312,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRulesetID"): listener.exitRulesetID(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRulesetID"): + return visitor.visitRulesetID(self) + else: + return visitor.visitChildren(self) + def rulesetID(self): + localctx = Parser.RulesetIDContext(self, self._ctx, self.state) self.enterRule(localctx, 140, self.RULE_rulesetID) try: self.enterOuterAlt(localctx, 1) - self.state = 1638 + self.state = 1649 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -14134,30 +15370,37 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRulesetSignature"): listener.exitRulesetSignature(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRulesetSignature"): + return visitor.visitRulesetSignature(self) + else: + return visitor.visitChildren(self) + def rulesetSignature(self): + localctx = Parser.RulesetSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 142, self.RULE_rulesetSignature) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1640 + self.state = 1651 _la = self._input.LA(1) if not (_la == Parser.VALUE_DOMAIN or _la == Parser.VARIABLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1641 + self.state = 1652 self.signature() - self.state = 1646 + self.state = 1657 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1642 + self.state = 1653 self.match(Parser.COMMA) - self.state = 1643 + self.state = 1654 self.signature() - self.state = 1648 + self.state = 1659 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14196,21 +15439,28 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSignature"): listener.exitSignature(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSignature"): + return visitor.visitSignature(self) + else: + return visitor.visitChildren(self) + def signature(self): + localctx = Parser.SignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 144, self.RULE_signature) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1649 + self.state = 1660 self.varID() - self.state = 1652 + self.state = 1663 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.AS: - self.state = 1650 + self.state = 1661 self.match(Parser.AS) - self.state = 1651 + self.state = 1662 self.alias() except RecognitionException as re: @@ -14251,23 +15501,30 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRuleClauseDatapoint"): listener.exitRuleClauseDatapoint(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleClauseDatapoint"): + return visitor.visitRuleClauseDatapoint(self) + else: + return visitor.visitChildren(self) + def ruleClauseDatapoint(self): + localctx = Parser.RuleClauseDatapointContext(self, self._ctx, self.state) self.enterRule(localctx, 146, self.RULE_ruleClauseDatapoint) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1654 + self.state = 1665 self.ruleItemDatapoint() - self.state = 1659 + self.state = 1670 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.EOL: - self.state = 1655 + self.state = 1666 self.match(Parser.EOL) - self.state = 1656 + self.state = 1667 self.ruleItemDatapoint() - self.state = 1661 + self.state = 1672 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14324,46 +15581,53 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRuleItemDatapoint"): listener.exitRuleItemDatapoint(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleItemDatapoint"): + return visitor.visitRuleItemDatapoint(self) + else: + return visitor.visitChildren(self) + def ruleItemDatapoint(self): + localctx = Parser.RuleItemDatapointContext(self, self._ctx, self.state) self.enterRule(localctx, 148, self.RULE_ruleItemDatapoint) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1664 + self.state = 1675 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 170, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 171, self._ctx) if la_ == 1: - self.state = 1662 + self.state = 1673 localctx.ruleName = self.match(Parser.IDENTIFIER) - self.state = 1663 + self.state = 1674 self.match(Parser.COLON) - self.state = 1670 + self.state = 1681 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.WHEN: - self.state = 1666 + self.state = 1677 self.match(Parser.WHEN) - self.state = 1667 + self.state = 1678 localctx.antecedentContiditon = self.exprComponent(0) - self.state = 1668 + self.state = 1679 self.match(Parser.THEN) - self.state = 1672 + self.state = 1683 localctx.consequentCondition = self.exprComponent(0) - self.state = 1674 + self.state = 1685 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.ERRORCODE: - self.state = 1673 + self.state = 1684 self.erCode() - self.state = 1677 + self.state = 1688 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.ERRORLEVEL: - self.state = 1676 + self.state = 1687 self.erLevel() except RecognitionException as re: @@ -14404,23 +15668,30 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRuleClauseHierarchical"): listener.exitRuleClauseHierarchical(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleClauseHierarchical"): + return visitor.visitRuleClauseHierarchical(self) + else: + return visitor.visitChildren(self) + def ruleClauseHierarchical(self): + localctx = Parser.RuleClauseHierarchicalContext(self, self._ctx, self.state) self.enterRule(localctx, 150, self.RULE_ruleClauseHierarchical) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1679 + self.state = 1690 self.ruleItemHierarchical() - self.state = 1684 + self.state = 1695 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.EOL: - self.state = 1680 + self.state = 1691 self.match(Parser.EOL) - self.state = 1681 + self.state = 1692 self.ruleItemHierarchical() - self.state = 1686 + self.state = 1697 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14466,35 +15737,42 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRuleItemHierarchical"): listener.exitRuleItemHierarchical(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRuleItemHierarchical"): + return visitor.visitRuleItemHierarchical(self) + else: + return visitor.visitChildren(self) + def ruleItemHierarchical(self): + localctx = Parser.RuleItemHierarchicalContext(self, self._ctx, self.state) self.enterRule(localctx, 152, self.RULE_ruleItemHierarchical) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1689 + self.state = 1700 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 175, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 176, self._ctx) if la_ == 1: - self.state = 1687 + self.state = 1698 localctx.ruleName = self.match(Parser.IDENTIFIER) - self.state = 1688 + self.state = 1699 self.match(Parser.COLON) - self.state = 1691 + self.state = 1702 self.codeItemRelation() - self.state = 1693 + self.state = 1704 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.ERRORCODE: - self.state = 1692 + self.state = 1703 self.erCode() - self.state = 1696 + self.state = 1707 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.ERRORLEVEL: - self.state = 1695 + self.state = 1706 self.erLevel() except RecognitionException as re: @@ -14541,31 +15819,38 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitHierRuleSignature"): listener.exitHierRuleSignature(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHierRuleSignature"): + return visitor.visitHierRuleSignature(self) + else: + return visitor.visitChildren(self) + def hierRuleSignature(self): + localctx = Parser.HierRuleSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 154, self.RULE_hierRuleSignature) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1698 + self.state = 1709 _la = self._input.LA(1) if not (_la == Parser.VALUE_DOMAIN or _la == Parser.VARIABLE): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) self.consume() - self.state = 1701 + self.state = 1712 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.CONDITION: - self.state = 1699 + self.state = 1710 self.match(Parser.CONDITION) - self.state = 1700 + self.state = 1711 self.valueDomainSignature() - self.state = 1703 + self.state = 1714 self.match(Parser.RULE) - self.state = 1704 + self.state = 1715 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -14605,23 +15890,30 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValueDomainSignature"): listener.exitValueDomainSignature(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainSignature"): + return visitor.visitValueDomainSignature(self) + else: + return visitor.visitChildren(self) + def valueDomainSignature(self): + localctx = Parser.ValueDomainSignatureContext(self, self._ctx, self.state) self.enterRule(localctx, 156, self.RULE_valueDomainSignature) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1706 + self.state = 1717 self.signature() - self.state = 1711 + self.state = 1722 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1707 + self.state = 1718 self.match(Parser.COMMA) - self.state = 1708 + self.state = 1719 self.signature() - self.state = 1713 + self.state = 1724 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14673,26 +15965,33 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCodeItemRelation"): listener.exitCodeItemRelation(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCodeItemRelation"): + return visitor.visitCodeItemRelation(self) + else: + return visitor.visitChildren(self) + def codeItemRelation(self): + localctx = Parser.CodeItemRelationContext(self, self._ctx, self.state) self.enterRule(localctx, 158, self.RULE_codeItemRelation) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1718 + self.state = 1729 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.WHEN: - self.state = 1714 + self.state = 1725 self.match(Parser.WHEN) - self.state = 1715 + self.state = 1726 self.exprComponent(0) - self.state = 1716 + self.state = 1727 self.match(Parser.THEN) - self.state = 1720 + self.state = 1731 localctx.codetemRef = self.valueDomainValue() - self.state = 1722 + self.state = 1733 self._errHandler.sync(self) _la = self._input.LA(1) if ((_la) & ~0x3F) == 0 and ( @@ -14706,12 +16005,12 @@ def codeItemRelation(self): | (1 << Parser.LE) ) ) != 0: - self.state = 1721 + self.state = 1732 self.comparisonOperand() - self.state = 1724 + self.state = 1735 self.codeItemRelationClause() - self.state = 1728 + self.state = 1739 self._errHandler.sync(self) _la = self._input.LA(1) while ( @@ -14730,9 +16029,9 @@ def codeItemRelation(self): != 0 ) ): - self.state = 1725 + self.state = 1736 self.codeItemRelationClause() - self.state = 1730 + self.state = 1741 self._errHandler.sync(self) _la = self._input.LA(1) @@ -14783,17 +16082,24 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCodeItemRelationClause"): listener.exitCodeItemRelationClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCodeItemRelationClause"): + return visitor.visitCodeItemRelationClause(self) + else: + return visitor.visitChildren(self) + def codeItemRelationClause(self): + localctx = Parser.CodeItemRelationClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 160, self.RULE_codeItemRelationClause) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1732 + self.state = 1743 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.PLUS or _la == Parser.MINUS: - self.state = 1731 + self.state = 1742 localctx.opAdd = self._input.LT(1) _la = self._input.LA(1) if not (_la == Parser.PLUS or _la == Parser.MINUS): @@ -14802,17 +16108,17 @@ def codeItemRelationClause(self): self._errHandler.reportMatch(self) self.consume() - self.state = 1734 + self.state = 1745 localctx.rightCodeItem = self.valueDomainValue() - self.state = 1739 + self.state = 1750 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.QLPAREN: - self.state = 1735 + self.state = 1746 self.match(Parser.QLPAREN) - self.state = 1736 + self.state = 1747 localctx.rightCondition = self.exprComponent(0) - self.state = 1737 + self.state = 1748 self.match(Parser.QRPAREN) except RecognitionException as re: @@ -14850,13 +16156,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValueDomainValue"): listener.exitValueDomainValue(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainValue"): + return visitor.visitValueDomainValue(self) + else: + return visitor.visitChildren(self) + def valueDomainValue(self): + localctx = Parser.ValueDomainValueContext(self, self._ctx, self.state) self.enterRule(localctx, 162, self.RULE_valueDomainValue) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1741 + self.state = 1752 _la = self._input.LA(1) if not ( ((_la - 241) & ~0x3F) == 0 @@ -14928,6 +16241,12 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRangeConstraint"): listener.exitRangeConstraint(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRangeConstraint"): + return visitor.visitRangeConstraint(self) + else: + return visitor.visitChildren(self) + class ConditionConstraintContext(ScalarTypeConstraintContext): def __init__( self, ANTLRParser, ctx: ParserRuleContext @@ -14952,44 +16271,51 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitConditionConstraint"): listener.exitConditionConstraint(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionConstraint"): + return visitor.visitConditionConstraint(self) + else: + return visitor.visitChildren(self) + def scalarTypeConstraint(self): + localctx = Parser.ScalarTypeConstraintContext(self, self._ctx, self.state) self.enterRule(localctx, 164, self.RULE_scalarTypeConstraint) self._la = 0 # Token type try: - self.state = 1758 + self.state = 1769 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.QLPAREN]: localctx = Parser.ConditionConstraintContext(self, localctx) self.enterOuterAlt(localctx, 1) - self.state = 1743 + self.state = 1754 self.match(Parser.QLPAREN) - self.state = 1744 + self.state = 1755 self.exprComponent(0) - self.state = 1745 + self.state = 1756 self.match(Parser.QRPAREN) pass elif token in [Parser.GLPAREN]: localctx = Parser.RangeConstraintContext(self, localctx) self.enterOuterAlt(localctx, 2) - self.state = 1747 + self.state = 1758 self.match(Parser.GLPAREN) - self.state = 1748 + self.state = 1759 self.scalarItem() - self.state = 1753 + self.state = 1764 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1749 + self.state = 1760 self.match(Parser.COMMA) - self.state = 1750 + self.state = 1761 self.scalarItem() - self.state = 1755 + self.state = 1766 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1756 + self.state = 1767 self.match(Parser.GRPAREN) pass else: @@ -15030,22 +16356,29 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitCompConstraint"): listener.exitCompConstraint(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitCompConstraint"): + return visitor.visitCompConstraint(self) + else: + return visitor.visitChildren(self) + def compConstraint(self): + localctx = Parser.CompConstraintContext(self, self._ctx, self.state) self.enterRule(localctx, 166, self.RULE_compConstraint) try: self.enterOuterAlt(localctx, 1) - self.state = 1760 + self.state = 1771 self.componentType() - self.state = 1763 + self.state = 1774 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.IDENTIFIER]: - self.state = 1761 + self.state = 1772 self.componentID() pass elif token in [Parser.OPTIONAL]: - self.state = 1762 + self.state = 1773 self.multModifier() pass else: @@ -15086,19 +16419,26 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitMultModifier"): listener.exitMultModifier(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitMultModifier"): + return visitor.visitMultModifier(self) + else: + return visitor.visitChildren(self) + def multModifier(self): + localctx = Parser.MultModifierContext(self, self._ctx, self.state) self.enterRule(localctx, 168, self.RULE_multModifier) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1765 + self.state = 1776 self.match(Parser.OPTIONAL) - self.state = 1767 + self.state = 1778 self._errHandler.sync(self) _la = self._input.LA(1) if _la == Parser.PLUS or _la == Parser.MUL: - self.state = 1766 + self.state = 1777 _la = self._input.LA(1) if not (_la == Parser.PLUS or _la == Parser.MUL): self._errHandler.recoverInline(self) @@ -15141,13 +16481,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValidationOutput"): listener.exitValidationOutput(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationOutput"): + return visitor.visitValidationOutput(self) + else: + return visitor.visitChildren(self) + def validationOutput(self): + localctx = Parser.ValidationOutputContext(self, self._ctx, self.state) self.enterRule(localctx, 170, self.RULE_validationOutput) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1769 + self.state = 1780 _la = self._input.LA(1) if not (_la == Parser.ALL or _la == Parser.INVALID or _la == Parser.ALL_MEASURES): self._errHandler.recoverInline(self) @@ -15198,13 +16545,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValidationMode"): listener.exitValidationMode(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValidationMode"): + return visitor.visitValidationMode(self) + else: + return visitor.visitChildren(self) + def validationMode(self): + localctx = Parser.ValidationModeContext(self, self._ctx, self.state) self.enterRule(localctx, 172, self.RULE_validationMode) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1771 + self.state = 1782 _la = self._input.LA(1) if not ( ((_la - 225) & ~0x3F) == 0 @@ -15266,25 +16620,32 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitConditionClause"): listener.exitConditionClause(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConditionClause"): + return visitor.visitConditionClause(self) + else: + return visitor.visitChildren(self) + def conditionClause(self): + localctx = Parser.ConditionClauseContext(self, self._ctx, self.state) self.enterRule(localctx, 174, self.RULE_conditionClause) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1773 + self.state = 1784 self.match(Parser.CONDITION) - self.state = 1774 + self.state = 1785 self.componentID() - self.state = 1779 + self.state = 1790 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1775 + self.state = 1786 self.match(Parser.COMMA) - self.state = 1776 + self.state = 1787 self.componentID() - self.state = 1781 + self.state = 1792 self._errHandler.sync(self) _la = self._input.LA(1) @@ -15320,13 +16681,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitInputMode"): listener.exitInputMode(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInputMode"): + return visitor.visitInputMode(self) + else: + return visitor.visitChildren(self) + def inputMode(self): + localctx = Parser.InputModeContext(self, self._ctx, self.state) self.enterRule(localctx, 176, self.RULE_inputMode) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1782 + self.state = 1793 _la = self._input.LA(1) if not (_la == Parser.DATASET or _la == Parser.DATASET_PRIORITY): self._errHandler.recoverInline(self) @@ -15365,14 +16733,21 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitImbalanceExpr"): listener.exitImbalanceExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitImbalanceExpr"): + return visitor.visitImbalanceExpr(self) + else: + return visitor.visitChildren(self) + def imbalanceExpr(self): + localctx = Parser.ImbalanceExprContext(self, self._ctx, self.state) self.enterRule(localctx, 178, self.RULE_imbalanceExpr) try: self.enterOuterAlt(localctx, 1) - self.state = 1784 + self.state = 1795 self.match(Parser.IMBALANCE) - self.state = 1785 + self.state = 1796 self.expr(0) except RecognitionException as re: localctx.exception = re @@ -15409,13 +16784,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitInputModeHierarchy"): listener.exitInputModeHierarchy(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInputModeHierarchy"): + return visitor.visitInputModeHierarchy(self) + else: + return visitor.visitChildren(self) + def inputModeHierarchy(self): + localctx = Parser.InputModeHierarchyContext(self, self._ctx, self.state) self.enterRule(localctx, 180, self.RULE_inputModeHierarchy) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1787 + self.state = 1798 _la = self._input.LA(1) if not (_la == Parser.DATASET or _la == Parser.RULE or _la == Parser.RULE_PRIORITY): self._errHandler.recoverInline(self) @@ -15454,13 +16836,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOutputModeHierarchy"): listener.exitOutputModeHierarchy(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOutputModeHierarchy"): + return visitor.visitOutputModeHierarchy(self) + else: + return visitor.visitChildren(self) + def outputModeHierarchy(self): + localctx = Parser.OutputModeHierarchyContext(self, self._ctx, self.state) self.enterRule(localctx, 182, self.RULE_outputModeHierarchy) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1789 + self.state = 1800 _la = self._input.LA(1) if not (_la == Parser.ALL or _la == Parser.COMPUTED): self._errHandler.recoverInline(self) @@ -15496,12 +16885,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitAlias"): listener.exitAlias(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitAlias"): + return visitor.visitAlias(self) + else: + return visitor.visitChildren(self) + def alias(self): + localctx = Parser.AliasContext(self, self._ctx, self.state) self.enterRule(localctx, 184, self.RULE_alias) try: self.enterOuterAlt(localctx, 1) - self.state = 1791 + self.state = 1802 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -15532,12 +16928,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitVarID"): listener.exitVarID(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVarID"): + return visitor.visitVarID(self) + else: + return visitor.visitChildren(self) + def varID(self): + localctx = Parser.VarIDContext(self, self._ctx, self.state) self.enterRule(localctx, 186, self.RULE_varID) try: self.enterOuterAlt(localctx, 1) - self.state = 1793 + self.state = 1804 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -15568,12 +16971,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitSimpleComponentId"): listener.exitSimpleComponentId(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSimpleComponentId"): + return visitor.visitSimpleComponentId(self) + else: + return visitor.visitChildren(self) + def simpleComponentId(self): + localctx = Parser.SimpleComponentIdContext(self, self._ctx, self.state) self.enterRule(localctx, 188, self.RULE_simpleComponentId) try: self.enterOuterAlt(localctx, 1) - self.state = 1795 + self.state = 1806 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -15610,20 +17020,27 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComponentID"): listener.exitComponentID(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComponentID"): + return visitor.visitComponentID(self) + else: + return visitor.visitChildren(self) + def componentID(self): + localctx = Parser.ComponentIDContext(self, self._ctx, self.state) self.enterRule(localctx, 190, self.RULE_componentID) try: self.enterOuterAlt(localctx, 1) - self.state = 1797 + self.state = 1808 self.match(Parser.IDENTIFIER) - self.state = 1800 + self.state = 1811 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 190, self._ctx) + la_ = self._interp.adaptivePredict(self._input, 191, self._ctx) if la_ == 1: - self.state = 1798 + self.state = 1809 self.match(Parser.MEMBERSHIP) - self.state = 1799 + self.state = 1810 self.match(Parser.IDENTIFIER) except RecognitionException as re: @@ -15670,29 +17087,36 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitLists"): listener.exitLists(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitLists"): + return visitor.visitLists(self) + else: + return visitor.visitChildren(self) + def lists(self): + localctx = Parser.ListsContext(self, self._ctx, self.state) self.enterRule(localctx, 192, self.RULE_lists) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1802 + self.state = 1813 self.match(Parser.GLPAREN) - self.state = 1803 + self.state = 1814 self.scalarItem() - self.state = 1808 + self.state = 1819 self._errHandler.sync(self) _la = self._input.LA(1) while _la == Parser.COMMA: - self.state = 1804 + self.state = 1815 self.match(Parser.COMMA) - self.state = 1805 + self.state = 1816 self.scalarItem() - self.state = 1810 + self.state = 1821 self._errHandler.sync(self) _la = self._input.LA(1) - self.state = 1811 + self.state = 1822 self.match(Parser.GRPAREN) except RecognitionException as re: localctx.exception = re @@ -15726,14 +17150,21 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitErCode"): listener.exitErCode(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitErCode"): + return visitor.visitErCode(self) + else: + return visitor.visitChildren(self) + def erCode(self): + localctx = Parser.ErCodeContext(self, self._ctx, self.state) self.enterRule(localctx, 194, self.RULE_erCode) try: self.enterOuterAlt(localctx, 1) - self.state = 1813 + self.state = 1824 self.match(Parser.ERRORCODE) - self.state = 1814 + self.state = 1825 self.constant() except RecognitionException as re: localctx.exception = re @@ -15767,14 +17198,21 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitErLevel"): listener.exitErLevel(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitErLevel"): + return visitor.visitErLevel(self) + else: + return visitor.visitChildren(self) + def erLevel(self): + localctx = Parser.ErLevelContext(self, self._ctx, self.state) self.enterRule(localctx, 196, self.RULE_erLevel) try: self.enterOuterAlt(localctx, 1) - self.state = 1816 + self.state = 1827 self.match(Parser.ERRORLEVEL) - self.state = 1817 + self.state = 1828 self.constant() except RecognitionException as re: localctx.exception = re @@ -15820,13 +17258,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComparisonOperand"): listener.exitComparisonOperand(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComparisonOperand"): + return visitor.visitComparisonOperand(self) + else: + return visitor.visitChildren(self) + def comparisonOperand(self): + localctx = Parser.ComparisonOperandContext(self, self._ctx, self.state) self.enterRule(localctx, 198, self.RULE_comparisonOperand) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1819 + self.state = 1830 _la = self._input.LA(1) if not ( ((_la) & ~0x3F) == 0 @@ -15879,11 +17324,18 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOptionalExpr"): listener.exitOptionalExpr(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOptionalExpr"): + return visitor.visitOptionalExpr(self) + else: + return visitor.visitChildren(self) + def optionalExpr(self): + localctx = Parser.OptionalExprContext(self, self._ctx, self.state) self.enterRule(localctx, 200, self.RULE_optionalExpr) try: - self.state = 1823 + self.state = 1834 self._errHandler.sync(self) token = self._input.LA(1) if token in [ @@ -15973,12 +17425,12 @@ def optionalExpr(self): Parser.IDENTIFIER, ]: self.enterOuterAlt(localctx, 1) - self.state = 1821 + self.state = 1832 self.expr(0) pass elif token in [Parser.OPTIONAL]: self.enterOuterAlt(localctx, 2) - self.state = 1822 + self.state = 1833 self.match(Parser.OPTIONAL) pass else: @@ -16016,11 +17468,18 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOptionalExprComponent"): listener.exitOptionalExprComponent(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOptionalExprComponent"): + return visitor.visitOptionalExprComponent(self) + else: + return visitor.visitChildren(self) + def optionalExprComponent(self): + localctx = Parser.OptionalExprComponentContext(self, self._ctx, self.state) self.enterRule(localctx, 202, self.RULE_optionalExprComponent) try: - self.state = 1827 + self.state = 1838 self._errHandler.sync(self) token = self._input.LA(1) if token in [ @@ -16098,12 +17557,12 @@ def optionalExprComponent(self): Parser.IDENTIFIER, ]: self.enterOuterAlt(localctx, 1) - self.state = 1825 + self.state = 1836 self.exprComponent(0) pass elif token in [Parser.OPTIONAL]: self.enterOuterAlt(localctx, 2) - self.state = 1826 + self.state = 1837 self.match(Parser.OPTIONAL) pass else: @@ -16150,36 +17609,43 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitComponentRole"): listener.exitComponentRole(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitComponentRole"): + return visitor.visitComponentRole(self) + else: + return visitor.visitChildren(self) + def componentRole(self): + localctx = Parser.ComponentRoleContext(self, self._ctx, self.state) self.enterRule(localctx, 204, self.RULE_componentRole) try: - self.state = 1834 + self.state = 1845 self._errHandler.sync(self) token = self._input.LA(1) if token in [Parser.MEASURE]: self.enterOuterAlt(localctx, 1) - self.state = 1829 + self.state = 1840 self.match(Parser.MEASURE) pass elif token in [Parser.COMPONENT]: self.enterOuterAlt(localctx, 2) - self.state = 1830 + self.state = 1841 self.match(Parser.COMPONENT) pass elif token in [Parser.DIMENSION]: self.enterOuterAlt(localctx, 3) - self.state = 1831 + self.state = 1842 self.match(Parser.DIMENSION) pass elif token in [Parser.ATTRIBUTE]: self.enterOuterAlt(localctx, 4) - self.state = 1832 + self.state = 1843 self.match(Parser.ATTRIBUTE) pass elif token in [Parser.VIRAL]: self.enterOuterAlt(localctx, 5) - self.state = 1833 + self.state = 1844 self.viralAttribute() pass else: @@ -16217,14 +17683,21 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitViralAttribute"): listener.exitViralAttribute(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitViralAttribute"): + return visitor.visitViralAttribute(self) + else: + return visitor.visitChildren(self) + def viralAttribute(self): + localctx = Parser.ViralAttributeContext(self, self._ctx, self.state) self.enterRule(localctx, 206, self.RULE_viralAttribute) try: self.enterOuterAlt(localctx, 1) - self.state = 1836 + self.state = 1847 self.match(Parser.VIRAL) - self.state = 1837 + self.state = 1848 self.match(Parser.ATTRIBUTE) except RecognitionException as re: localctx.exception = re @@ -16255,12 +17728,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitValueDomainID"): listener.exitValueDomainID(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitValueDomainID"): + return visitor.visitValueDomainID(self) + else: + return visitor.visitChildren(self) + def valueDomainID(self): + localctx = Parser.ValueDomainIDContext(self, self._ctx, self.state) self.enterRule(localctx, 208, self.RULE_valueDomainID) try: self.enterOuterAlt(localctx, 1) - self.state = 1839 + self.state = 1850 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -16291,12 +17771,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitOperatorID"): listener.exitOperatorID(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOperatorID"): + return visitor.visitOperatorID(self) + else: + return visitor.visitChildren(self) + def operatorID(self): + localctx = Parser.OperatorIDContext(self, self._ctx, self.state) self.enterRule(localctx, 210, self.RULE_operatorID) try: self.enterOuterAlt(localctx, 1) - self.state = 1841 + self.state = 1852 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -16327,12 +17814,19 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRoutineName"): listener.exitRoutineName(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRoutineName"): + return visitor.visitRoutineName(self) + else: + return visitor.visitChildren(self) + def routineName(self): + localctx = Parser.RoutineNameContext(self, self._ctx, self.state) self.enterRule(localctx, 212, self.RULE_routineName) try: self.enterOuterAlt(localctx, 1) - self.state = 1843 + self.state = 1854 self.match(Parser.IDENTIFIER) except RecognitionException as re: localctx.exception = re @@ -16375,13 +17869,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitConstant"): listener.exitConstant(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitConstant"): + return visitor.visitConstant(self) + else: + return visitor.visitChildren(self) + def constant(self): + localctx = Parser.ConstantContext(self, self._ctx, self.state) self.enterRule(localctx, 214, self.RULE_constant) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1845 + self.state = 1856 _la = self._input.LA(1) if not ( _la == Parser.NULL_CONSTANT @@ -16456,13 +17957,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitBasicScalarType"): listener.exitBasicScalarType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBasicScalarType"): + return visitor.visitBasicScalarType(self) + else: + return visitor.visitChildren(self) + def basicScalarType(self): + localctx = Parser.BasicScalarTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 216, self.RULE_basicScalarType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1847 + self.state = 1858 _la = self._input.LA(1) if not ( ( @@ -16520,13 +18028,20 @@ def exitRule(self, listener: ParseTreeListener): if hasattr(listener, "exitRetainType"): listener.exitRetainType(self) + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitRetainType"): + return visitor.visitRetainType(self) + else: + return visitor.visitChildren(self) + def retainType(self): + localctx = Parser.RetainTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 218, self.RULE_retainType) self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) - self.state = 1849 + self.state = 1860 _la = self._input.LA(1) if not (_la == Parser.ALL or _la == Parser.BOOLEAN_CONSTANT): self._errHandler.recoverInline(self) diff --git a/src/vtlengine/AST/VtlVisitor.py b/src/vtlengine/AST/VtlVisitor.py index b937e4bfc..f08bc7f83 100644 --- a/src/vtlengine/AST/VtlVisitor.py +++ b/src/vtlengine/AST/VtlVisitor.py @@ -532,6 +532,10 @@ def visitSimpleScalar(self, ctx: Parser.SimpleScalarContext): def visitScalarWithCast(self, ctx: Parser.ScalarWithCastContext): return self.visitChildren(ctx) + # Visit a parse tree produced by Parser#scalarVarWithCast. + def visitScalarVarWithCast(self, ctx: Parser.ScalarVarWithCastContext): + return self.visitChildren(ctx) + # Visit a parse tree produced by Parser#joinClauseWithoutUsing. def visitJoinClauseWithoutUsing(self, ctx: Parser.JoinClauseWithoutUsingContext): return self.visitChildren(ctx) diff --git a/src/vtlengine/Exceptions/messages.py b/src/vtlengine/Exceptions/messages.py index 4b89fdc91..cf5be0a0a 100644 --- a/src/vtlengine/Exceptions/messages.py +++ b/src/vtlengine/Exceptions/messages.py @@ -264,6 +264,12 @@ "message": "Component {comp_name} not found in Dataset {dataset_name}.", "description": "Occurs when a referenced component is missing from the Dataset.", }, + "1-1-1-11": { + "message": "At op {op}: Sub comparison is not allowed between components. " + "Please check sub comparison in Dataset {dataset_name} is between a Component and a " + "Scalar/Constant.", + "description": "Occurs when a sub operation attempts to compare components.", + }, "1-1-1-13": { "message": "At op {op}: Component {comp_name} role must be '{role_1}', found '{role_2}'.", "description": "Raised when a Dataset component has an unexpected role for the operation.", diff --git a/src/vtlengine/Operators/Clause.py b/src/vtlengine/Operators/Clause.py index 6e56bf0cb..319615b25 100644 --- a/src/vtlengine/Operators/Clause.py +++ b/src/vtlengine/Operators/Clause.py @@ -1,3 +1,4 @@ +import re from copy import copy from typing import List, Type, Union @@ -318,6 +319,12 @@ def validate(cls, operands: List[DataComponent], dataset: Dataset) -> Dataset: raise SemanticError("1-2-10", op=cls.op) for operand in operands: if operand.name not in dataset.components: + if re.match(r"__VDC_\d+__", operand.name): + raise SemanticError( + "1-1-1-11", + op=cls.op, + dataset_name=dataset_name, + ) raise SemanticError( "1-1-1-10", op=cls.op, diff --git a/src/vtlengine/Operators/Numeric.py b/src/vtlengine/Operators/Numeric.py index a8c1f6847..e748ef969 100644 --- a/src/vtlengine/Operators/Numeric.py +++ b/src/vtlengine/Operators/Numeric.py @@ -47,7 +47,7 @@ def apply_operation_component(cls, series: Any) -> Any: if cls.pc_func is not None: arr = series.values._pa_array return pd.Series( - pd.arrays.ArrowExtensionArray(cls.pc_func(arr)), # type: ignore[attr-defined] + pd.arrays.ArrowExtensionArray(cls.pc_func(arr)), # type: ignore[attr-defined,unused-ignore] index=series.index, ) return super().apply_operation_component(series) diff --git a/tests/Cast/data/DataStructure/input/GH_539_1-1.json b/tests/Cast/data/DataStructure/input/GH_539_1-1.json new file mode 100644 index 000000000..31bd21eeb --- /dev/null +++ b/tests/Cast/data/DataStructure/input/GH_539_1-1.json @@ -0,0 +1,27 @@ +{ + "datasets": [ + { + "name": "DS_1", + "DataStructure": [ + { + "name": "Id_1", + "type": "Integer", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Id_2", + "type": "String", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Me_1", + "type": "Integer", + "nullable": true, + "role": "Measure" + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/DataStructure/input/GH_539_1-2.json b/tests/Cast/data/DataStructure/input/GH_539_1-2.json new file mode 100644 index 000000000..85874f742 --- /dev/null +++ b/tests/Cast/data/DataStructure/input/GH_539_1-2.json @@ -0,0 +1,8 @@ +{ + "scalars": [ + { + "name": "sc_1", + "type": "Integer" + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/DataStructure/input/GH_539_2-1.json b/tests/Cast/data/DataStructure/input/GH_539_2-1.json new file mode 100644 index 000000000..31bd21eeb --- /dev/null +++ b/tests/Cast/data/DataStructure/input/GH_539_2-1.json @@ -0,0 +1,27 @@ +{ + "datasets": [ + { + "name": "DS_1", + "DataStructure": [ + { + "name": "Id_1", + "type": "Integer", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Id_2", + "type": "String", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Me_1", + "type": "Integer", + "nullable": true, + "role": "Measure" + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/DataStructure/output/GH_539_1-1.json b/tests/Cast/data/DataStructure/output/GH_539_1-1.json new file mode 100644 index 000000000..56672d9c3 --- /dev/null +++ b/tests/Cast/data/DataStructure/output/GH_539_1-1.json @@ -0,0 +1,21 @@ +{ + "datasets": [ + { + "name": "DS_r", + "DataStructure": [ + { + "name": "Id_1", + "type": "Integer", + "nullable": false, + "role": "Identifier" + }, + { + "name": "Me_1", + "type": "Integer", + "nullable": true, + "role": "Measure" + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/Cast/data/Dataset/input/GH_539_1-1.csv b/tests/Cast/data/Dataset/input/GH_539_1-1.csv new file mode 100644 index 000000000..53e89f364 --- /dev/null +++ b/tests/Cast/data/Dataset/input/GH_539_1-1.csv @@ -0,0 +1,5 @@ +Id_1,Id_2,Me_1 +1,1,10 +2,1,20 +1,2,30 +2,2,40 \ No newline at end of file diff --git a/tests/Cast/data/Dataset/output/GH_539_1-1.csv b/tests/Cast/data/Dataset/output/GH_539_1-1.csv new file mode 100644 index 000000000..7677d02e0 --- /dev/null +++ b/tests/Cast/data/Dataset/output/GH_539_1-1.csv @@ -0,0 +1,3 @@ +Id_1,Me_1 +1,10 +2,20 \ No newline at end of file diff --git a/tests/Cast/data/vtl/GH_539_1.vtl b/tests/Cast/data/vtl/GH_539_1.vtl new file mode 100644 index 000000000..579153664 --- /dev/null +++ b/tests/Cast/data/vtl/GH_539_1.vtl @@ -0,0 +1 @@ +DS_r <- DS_1[sub Id_2 = cast(sc_1, string)]; \ No newline at end of file diff --git a/tests/Cast/data/vtl/GH_539_2.vtl b/tests/Cast/data/vtl/GH_539_2.vtl new file mode 100644 index 000000000..af5c381f3 --- /dev/null +++ b/tests/Cast/data/vtl/GH_539_2.vtl @@ -0,0 +1 @@ +DS_r <- DS_1[sub Id_2 = cast(Id_1, string)]; \ No newline at end of file diff --git a/tests/Cast/test_cast.py b/tests/Cast/test_cast.py index 205249ba4..0c15e57fd 100644 --- a/tests/Cast/test_cast.py +++ b/tests/Cast/test_cast.py @@ -69,6 +69,27 @@ def test_GH_537_1(self): self.BaseTest(code, number_inputs, references_names=reference_names) + def test_GH_539_1(self): + """ + Solves bug report in github issue #539: sub fails whith scalar as VarID casting + """ + code = "GH_539_1" + number_inputs = 2 + reference_names = ["1"] + scalars = {"sc_1": 1} + + self.BaseTest(code, number_inputs, references_names=reference_names, scalars=scalars) + + def test_GH_539_2(self): + """ + Solves bug report in github issue #539: sub fails whith scalar as VarID casting + """ + code = "GH_539_2" + number_inputs = 1 + exception_code = "1-1-1-11" # sub comparison is not allowed between components + + self.NewSemanticExceptionTest(code, number_inputs, exception_code) + # =========================================================================== # Comprehensive explicit cast tests (VTL 2.2) - Without mask