From bb5931526b0c1ce67203866b170d7e5ee9805b10 Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Mon, 26 Aug 2024 20:44:21 +0530 Subject: [PATCH 01/19] Antlr grammar for SubstraitTypes and test file format --- grammar/Makefile | 9 ++ grammar/SubstraitLexer.g4 | 118 +++++++++++++++++++++ grammar/SubstraitType.g4 | 208 ++++++++++++++++++++++++++++++++++++ grammar/TestFileLexer.g4 | 111 ++++++++++++++++++++ grammar/TestFileParser.g4 | 215 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 661 insertions(+) create mode 100644 grammar/Makefile create mode 100644 grammar/SubstraitLexer.g4 create mode 100644 grammar/SubstraitType.g4 create mode 100644 grammar/TestFileLexer.g4 create mode 100644 grammar/TestFileParser.g4 diff --git a/grammar/Makefile b/grammar/Makefile new file mode 100644 index 000000000..83960ea22 --- /dev/null +++ b/grammar/Makefile @@ -0,0 +1,9 @@ +ANTLR_JAR=antlr-4.13.2-complete.jar +GRAMMARS=SubstraitLexer.g4 SubstraitType.g4 TestFileLexer.g4 TestFileParser.g4 +OUTPUT_DIR=../coverage/antlr_generated + +generate: + java -jar $(ANTLR_JAR) -visitor -Dlanguage=Python3 -o $(OUTPUT_DIR) $(GRAMMARS) + +clean: + rm -rf $(OUTPUT_DIR)/*.py diff --git a/grammar/SubstraitLexer.g4 b/grammar/SubstraitLexer.g4 new file mode 100644 index 000000000..508721383 --- /dev/null +++ b/grammar/SubstraitLexer.g4 @@ -0,0 +1,118 @@ +lexer grammar SubstraitLexer; + +// Whitespace and comment handling +LineComment : '//' ~[\r\n]* -> channel(HIDDEN) ; +BlockComment : ( '/*' ( ~'*' | '*'+ ~[*/] ) '*'* '*/' ) -> channel(HIDDEN) ; +Whitespace : [ \t\r\n]+ -> channel(HIDDEN) ; + +// Substrait is case-insensitive, ANTLR is not. So, in order to define our +// keywords in a somewhat readable way, we have to define these shortcuts. + +fragment A : [aA]; +fragment B : [bB]; +fragment C : [cC]; +fragment D : [dD]; +fragment E : [eE]; +fragment F : [fF]; +fragment G : [gG]; +fragment H : [hH]; +fragment I : [iI]; +fragment J : [jJ]; +fragment K : [kK]; +fragment L : [lL]; +fragment M : [mM]; +fragment N : [nN]; +fragment O : [oO]; +fragment P : [pP]; +fragment Q : [qQ]; +fragment R : [rR]; +fragment S : [sS]; +fragment T : [tT]; +fragment U : [uU]; +fragment V : [vV]; +fragment W : [wW]; +fragment X : [xX]; +fragment Y : [yY]; +fragment Z : [zZ]; + +fragment DIGIT: [0-9]; + +fragment INTEGER + : '0' + | [1-9] [0-9]* + ; + +// Syntactic keywords. +If : I F; +Then : T H E N; +Else : E L S E; + +// TYPES +Boolean : B O O L E A N; +I8 : I '8'; +I16 : I '16'; +I32 : I '32'; +I64 : I '64'; +FP32 : F P '32'; +FP64 : F P '64'; +String : S T R I N G; +Binary : B I N A R Y; +Timestamp: T I M E S T A M P; +TimestampTZ: T I M E S T A M P '_' T Z; +Date : D A T E; +Time : T I M E; +IntervalYear: I N T E R V A L '_' Y E A R; +IntervalDay: I N T E R V A L '_' D A Y; +UUID : U U I D; +Decimal : D E C I M A L; +PrecisionTimestamp: P R E C I S I O N '_' T I M E S T A M P; +PrecisionTimestampTZ: P R E C I S I O N '_' T I M E S T A M P '_' T Z; +FixedChar: F I X E D C H A R; +VarChar : V A R C H A R; +FixedBinary: F I X E D B I N A R Y; +Struct : S T R U C T; +NStruct : N S T R U C T; +List : L I S T; +Map : M A P; +ANY : A N Y; +UserDefined: U '!'; + +// short names for types +Bool: B O O L; +Str: S T R; +VBin: V B I N; +Ts: T S; +TsTZ: T S T Z; +IYear: I Y E A R; +IDay: I D A Y; +Dec: D E C; +PTs: P T S; +PTsTZ: P T S T Z; +FChar: F C H A R; +VChar: V C H A R; +FBin: F B I N; + +DOUBLE_COLON: '::'; + +IDENTIFIER + : [a-zA-Z_] [a-zA-Z0-9_]* + ; + +// ORGANIZE +O_ANGLE_BRACKET: '<'; +C_ANGLE_BRACKET: '>'; +OPAREN: '('; +CPAREN: ')'; +OBRACKET: '['; +CBRACKET: ']'; +COMMA: ','; +EQ: '='; +COLON: ':'; +QMARK: '?'; +HASH: '#'; +DOT: '.'; + +STRING + : '\'' ('\\' . | '\'\'' | ~['\\])* '\'' + ; + diff --git a/grammar/SubstraitType.g4 b/grammar/SubstraitType.g4 new file mode 100644 index 000000000..9323a598e --- /dev/null +++ b/grammar/SubstraitType.g4 @@ -0,0 +1,208 @@ +grammar SubstraitType; + +// +fragment A : [aA]; +fragment B : [bB]; +fragment C : [cC]; +fragment D : [dD]; +fragment E : [eE]; +fragment F : [fF]; +fragment G : [gG]; +fragment H : [hH]; +fragment I : [iI]; +fragment J : [jJ]; +fragment K : [kK]; +fragment L : [lL]; +fragment M : [mM]; +fragment N : [nN]; +fragment O : [oO]; +fragment P : [pP]; +fragment Q : [qQ]; +fragment R : [rR]; +fragment S : [sS]; +fragment T : [tT]; +fragment U : [uU]; +fragment V : [vV]; +fragment W : [wW]; +fragment X : [xX]; +fragment Y : [yY]; +fragment Z : [zZ]; + + +If : I F; +Then : T H E N; +Else : E L S E; + +// TYPES +Boolean : B O O L E A N; +I8 : I '8'; +I16 : I '16'; +I32 : I '32'; +I64 : I '64'; +FP32 : F P '32'; +FP64 : F P '64'; +String : S T R I N G; +Binary : B I N A R Y; +Timestamp: T I M E S T A M P; +TimestampTZ: T I M E S T A M P '_' T Z; +Date : D A T E; +Time : T I M E; +IntervalYear: I N T E R V A L '_' Y E A R; +IntervalDay: I N T E R V A L '_' D A Y; +UUID : U U I D; +Decimal : D E C I M A L; +PrecisionTimestamp: P R E C I S I O N '_' T I M E S T A M P; +PrecisionTimestampTZ: P R E C I S I O N '_' T I M E S T A M P '_' T Z; +FixedChar: F I X E D C H A R; +VarChar : V A R C H A R; +FixedBinary: F I X E D B I N A R Y; +Struct : S T R U C T; +NStruct : N S T R U C T; +List : L I S T; +Map : M A P; +ANY : A N Y; +UserDefined: U '!'; + + +// OPERATIONS +And : A N D; +Or : O R; +Assign : ':='; + +// COMPARE +Eq : '='; +NotEquals: '!='; +Gte : '>='; +Lte : '<='; +Gt : '>'; +Lt : '<'; +Bang : '!'; + + +// MATH +Plus : '+'; +Minus : '-'; +Asterisk : '*'; +ForwardSlash : '/'; +Percent : '%'; + +// ORGANIZE +OBracket : '['; +CBracket : ']'; +OParen : '('; +CParen : ')'; +SColon : ';'; +Comma : ','; +QMark : '?'; +Colon : ':'; +SingleQuote: '\''; + + +Number + : '-'? Int + ; + +Identifier + : ('a'..'z' | 'A'..'Z' | '_' | '$') ('a'..'z' | 'A'..'Z' | '_' | '$' | Digit)* + ; + +LineComment + : '//' ~[\r\n]* -> channel(HIDDEN) + ; + +BlockComment + : ( '/*' + ( '/'* BlockComment + | ~[/*] + | '/'+ ~[/*] + | '*'+ ~[/*] + )* + '*'* + '*/' + ) -> channel(HIDDEN) + ; + +Whitespace + : [ \t]+ -> channel(HIDDEN) + ; + +Newline + : ( '\r' '\n'? + | '\n' + ) + ; + + +fragment Int + : '1'..'9' Digit* + | '0' + ; + +fragment Digit + : '0'..'9' + ; + +start: expr EOF; + +scalarType + : Boolean #Boolean + | I8 #i8 + | I16 #i16 + | I32 #i32 + | I64 #i64 + | FP32 #fp32 + | FP64 #fp64 + | String #string + | Binary #binary + | Timestamp #timestamp + | TimestampTZ #timestampTz + | Date #date + | Time #time + | IntervalDay #intervalDay + | IntervalYear #intervalYear + | UUID #uuid + | UserDefined Identifier #userDefined + ; + +parameterizedType + : FixedChar isnull='?'? Lt len=numericParameter Gt #fixedChar + | VarChar isnull='?'? Lt len=numericParameter Gt #varChar + | FixedBinary isnull='?'? Lt len=numericParameter Gt #fixedBinary + | Decimal isnull='?'? Lt precision=numericParameter Comma scale=numericParameter Gt #decimal + | PrecisionTimestamp isnull='?'? Lt precision=numericParameter Gt #precisionTimestamp + | PrecisionTimestampTZ isnull='?'? Lt precision=numericParameter Gt #precisionTimestampTZ + | Struct isnull='?'? Lt expr (Comma expr)* Gt #struct + | NStruct isnull='?'? Lt Identifier expr (Comma Identifier expr)* Gt #nStruct + | List isnull='?'? Lt expr Gt #list + | Map isnull='?'? Lt key=expr Comma value=expr Gt #map + ; + +numericParameter + : Number #numericLiteral + | Identifier #numericParameterName + | expr #numericExpression + ; + +anyType: ANY; + +type + : scalarType isnull='?'? + | parameterizedType + | anyType isnull='?'? + ; + +// : (OParen innerExpr CParen | innerExpr) + +expr + : OParen expr CParen #ParenExpression + | Identifier Eq expr Newline+ (Identifier Eq expr Newline+)* finalType=type Newline* #MultilineDefinition + | type #TypeLiteral + | number=Number #LiteralNumber + | identifier=Identifier isnull='?'? #TypeParam + | Identifier OParen (expr (Comma expr)*)? CParen #FunctionCall + | left=expr op=(And | Or | Plus | Minus | Lt | Gt | Eq | NotEquals | Lte | Gte | Asterisk | ForwardSlash) right=expr #BinaryExpr + | If ifExpr=expr Then thenExpr=expr Else elseExpr=expr #IfExpr + | (Bang) expr #NotExpr + | ifExpr=expr QMark thenExpr=expr Colon elseExpr=expr #Ternary + ; + diff --git a/grammar/TestFileLexer.g4 b/grammar/TestFileLexer.g4 new file mode 100644 index 000000000..fa555518f --- /dev/null +++ b/grammar/TestFileLexer.g4 @@ -0,0 +1,111 @@ +lexer grammar TestFileLexer; + +import SubstraitLexer; + + +SUBSTRAIT_SCALAR_TEST + : '### SUBSTRAIT_SCALAR_TEST:' + ; + +FORMAT_VERSION + : 'v' DIGIT+ ('.' DIGIT+)? + ; + +SUBSTRAIT_INCLUDE + : '### SUBSTRAIT_INCLUDE:' + ; + +DESCRIPTION_LINE + : '# ' ~[\r\n]* '\r'? '\n' + ; + +ERROR_RESULT + : '' + ; + +UNDEFINED_RESULT + : '' + ; + + +OVERFLOW: 'overlfow'; +ROUNDING: 'rounding'; +ERROR: 'ERROR'; +SATURATE: 'SATURATE'; +SILENT: 'SILENT'; +TIE_TO_EVEN: 'TIE_TO_EVEN'; +NAN: 'NAN'; + +STRING_LITERAL + : '\'' ('\\' . | '\'\'' | ~['\\])* '\'' + ; + +INTEGER_LITERAL + : [+-]? INTEGER + ; + +DECIMAL_LITERAL + : [+-]? [0-9]+ ('.' [0-9]+)? + ; + +FLOAT_LITERAL + : [+-]? [0-9]+ ('.' [0-9]*)? ( [eE] [+-]? [0-9]+ )? + | [+-]? 'inf' + | 'nan' | 'NaN' + | 'snan' + ; + +BOOLEAN_LITERAL + : 'true' | 'false' + ; + + +fragment FourDigits: [0-9][0-9][0-9][0-9]; +fragment TwoDigits: [0-9][0-9]; + +DATE_LITERAL + : '\'' FourDigits '-' TwoDigits '-' TwoDigits '\'' + ; + +TIME_LITERAL + : '\'' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? '\'' + ; + +TIMESTAMP_LITERAL + : '\'' FourDigits '-' TwoDigits '-' TwoDigits 'T' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? '\'' + ; + +TIMESTAMP_TZ_LITERAL + : '\'' FourDigits '-' TwoDigits '-' TwoDigits 'T' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? + [+-] TwoDigits ':' TwoDigits '\'' + ; + + +PERIOD_PREFIX: 'P'; +TIME_PREFIX: 'T'; +YEAR_SUFFIX: 'Y'; +M_SUFFIX: 'M'; // used for both months and minutes +DAY_SUFFIX: 'D'; +HOUR_SUFFIX: 'H'; +SECOND_SUFFIX: 'S'; +FRACTIONAL_SECOND_SUFFIX: 'F'; + +INTERVAL_YEAR_LITERAL + : '\'' PERIOD_PREFIX INTEGER_LITERAL YEAR_SUFFIX (INTEGER_LITERAL M_SUFFIX)? '\'' + | '\'' PERIOD_PREFIX INTEGER_LITERAL M_SUFFIX '\'' + ; + +INTERVAL_DAY_LITERAL + : '\'' PERIOD_PREFIX INTEGER_LITERAL DAY_SUFFIX (TIME_PREFIX TIME_INTERVAL)? '\'' + | '\'' PERIOD_PREFIX TIME_PREFIX TIME_INTERVAL '\'' + ; + +fragment TIME_INTERVAL + : INTEGER_LITERAL HOUR_SUFFIX (INTEGER_LITERAL M_SUFFIX)? (INTEGER_LITERAL SECOND_SUFFIX)? + (INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX)? + | INTEGER_LITERAL M_SUFFIX (INTEGER_LITERAL SECOND_SUFFIX)? (INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX)? + | INTEGER_LITERAL SECOND_SUFFIX (INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX)? + | INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX + ; + +NULL_LITERAL: 'null'; diff --git a/grammar/TestFileParser.g4 b/grammar/TestFileParser.g4 new file mode 100644 index 000000000..002c58c68 --- /dev/null +++ b/grammar/TestFileParser.g4 @@ -0,0 +1,215 @@ +parser grammar TestFileParser; + +options { + tokenVocab=TestFileLexer; // This imports the tokens from SubstraitLexer.g4 +} + +doc + : header (testGroup? testCase+)+ EOF + ; + +header + : version include + ; + +version + : SUBSTRAIT_SCALAR_TEST FORMAT_VERSION + ; + +include + : SUBSTRAIT_INCLUDE STRING (COMMA STRING)? + ; + +testGroup + : DESCRIPTION_LINE + ; + +testCase + : functionName=IDENTIFIER OPAREN arguments CPAREN ( OBRACKET func_options CBRACKET )? EQ result + ; + +arguments + : argument (COMMA argument)* + ; + +result + : argument + | substraitError + ; + +argument + : nullArg + | i8Arg | i16Arg | i32Arg | i64Arg + | fp32Arg | fp64Arg + | booleanArg + | stringArg + | decimalArg + | dateArg + | timeArg + | timestampArg + | timestampTzArg + | intervalYearArg + | intervalDayArg + ; + +nullArg: NULL_LITERAL DOUBLE_COLON datatype; + +i8Arg: INTEGER_LITERAL DOUBLE_COLON I8; + +i16Arg: INTEGER_LITERAL DOUBLE_COLON I16; + +i32Arg: INTEGER_LITERAL DOUBLE_COLON I32; + +i64Arg: INTEGER_LITERAL DOUBLE_COLON I64; + +fp32Arg + : FLOAT_LITERAL DOUBLE_COLON FP32 + ; + +fp64Arg + : FLOAT_LITERAL DOUBLE_COLON FP64 + ; + +booleanArg + : BOOLEAN_LITERAL DOUBLE_COLON Bool + ; + +stringArg + : STRING_LITERAL DOUBLE_COLON String + ; + +decimalArg + : DECIMAL_LITERAL DOUBLE_COLON (FP32 | FP64 | decimalType) + | INTEGER_LITERAL DOUBLE_COLON (FP32 | FP64 | decimalType) + | FLOAT_LITERAL DOUBLE_COLON decimalType + ; + +dateArg + : DATE_LITERAL DOUBLE_COLON Date + ; + +timeArg + : TIME_LITERAL DOUBLE_COLON Time + ; + +timestampArg + : TIMESTAMP_LITERAL DOUBLE_COLON Timestamp + ; + +timestampTzArg + : TIMESTAMP_TZ_LITERAL DOUBLE_COLON TimestampTZ + ; + +intervalYearArg + : INTERVAL_YEAR_LITERAL DOUBLE_COLON IntervalYear + ; + +intervalDayArg + : INTERVAL_DAY_LITERAL DOUBLE_COLON IntervalDay + ; + +intervalYearLiteral + : PERIOD_PREFIX (years=INTEGER_LITERAL YEAR_SUFFIX) (months=INTEGER_LITERAL M_SUFFIX)? + | PERIOD_PREFIX (months=INTEGER_LITERAL M_SUFFIX) + ; + +intervalDayLiteral + : PERIOD_PREFIX (days=INTEGER_LITERAL DAY_SUFFIX) (TIME_PREFIX timeInterval)? + | PERIOD_PREFIX TIME_PREFIX timeInterval + ; + +timeInterval + : hours=INTEGER_LITERAL HOUR_SUFFIX (minutes=INTEGER_LITERAL M_SUFFIX)? (seconds=INTEGER_LITERAL SECOND_SUFFIX)? + (fractionalSeconds=INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX)? + | minutes=INTEGER_LITERAL M_SUFFIX (seconds=INTEGER_LITERAL SECOND_SUFFIX)? (fractionalSeconds=INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX)? + | seconds=INTEGER_LITERAL SECOND_SUFFIX (fractionalSeconds=INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX)? + | fractionalSeconds=INTEGER_LITERAL FRACTIONAL_SECOND_SUFFIX + ; + +datatype + : scalarType + | parameterizedType + ; + +scalarType + : Bool #Boolean + | I8 #i8 + | I16 #i16 + | I32 #i32 + | I64 #i64 + | FP32 #fp32 + | FP64 #fp64 + | String #string + | Binary #binary + | Timestamp #timestamp + | TimestampTZ #timestampTz + | Date #date + | Time #time + | IntervalDay #intervalDay + | IntervalYear #intervalYear + | UUID #uuid + | UserDefined IDENTIFIER #userDefined + ; + +fixedCharType + : FixedChar isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #fixedChar + ; + +varCharType + : VarChar isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #varChar + ; + +fixedBinaryType + : FixedBinary isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #fixedBinary + ; + +decimalType + : Decimal isnull=QMARK? (O_ANGLE_BRACKET precision=numericParameter COMMA scale=numericParameter C_ANGLE_BRACKET)? #decimal + ; + +precisionTimestampType + : PrecisionTimestamp isnull=QMARK? O_ANGLE_BRACKET precision=numericParameter C_ANGLE_BRACKET #precisionTimestamp + ; + +precisionTimestampTZType + : PrecisionTimestampTZ isnull=QMARK? O_ANGLE_BRACKET precision=numericParameter C_ANGLE_BRACKET #precisionTimestampTZ + ; + +parameterizedType + : fixedCharType + | varCharType + | fixedBinaryType + | decimalType + | precisionTimestampType + | precisionTimestampTZType +// TODO implement the rest of the parameterized types +// | Struct isnull='?'? Lt expr (Comma expr)* Gt #struct +// | NStruct isnull='?'? Lt Identifier expr (Comma Identifier expr)* Gt #nStruct +// | List isnull='?'? Lt expr Gt #list +// | Map isnull='?'? Lt key=expr Comma value=expr Gt #map + ; + +numericParameter + : INTEGER_LITERAL #numericLiteral + ; + +substraitError + : ERROR_RESULT | UNDEFINED_RESULT + ; + +func_option + : option_name COLON option_value + ; + +option_name + : OVERFLOW | ROUNDING + | IDENTIFIER + ; + +option_value + : ERROR | SATURATE | SILENT | TIE_TO_EVEN | NAN + ; + +func_options + : func_option (COMMA func_option)* + ; From ef92bca2f3376d00ca292b7873f97bda4e65720d Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Tue, 27 Aug 2024 06:06:53 +0530 Subject: [PATCH 02/19] Some fixes still not working --- grammar/Makefile | 4 +- grammar/SubstraitLexer.g4 | 6 +- grammar/SubstraitType.g4 | 86 ++++------------------- grammar/TestFileLexer.g4 | 26 ++++--- grammar/TestFileParser.g4 | 27 +++---- tests/cases/arithmetic/add.test | 31 ++++++++ tests/cases/arithmetic_decimal/power.test | 21 ++++++ tests/cases/datetime/lt_datetime.test | 25 +++++++ tests/coverage/coverage.py | 84 ++++++++++++++++++++++ tests/coverage/visitor.py | 19 +++++ 10 files changed, 225 insertions(+), 104 deletions(-) create mode 100644 tests/cases/arithmetic/add.test create mode 100644 tests/cases/arithmetic_decimal/power.test create mode 100644 tests/cases/datetime/lt_datetime.test create mode 100755 tests/coverage/coverage.py create mode 100644 tests/coverage/visitor.py diff --git a/grammar/Makefile b/grammar/Makefile index 83960ea22..ca94c7bee 100644 --- a/grammar/Makefile +++ b/grammar/Makefile @@ -1,6 +1,6 @@ ANTLR_JAR=antlr-4.13.2-complete.jar -GRAMMARS=SubstraitLexer.g4 SubstraitType.g4 TestFileLexer.g4 TestFileParser.g4 -OUTPUT_DIR=../coverage/antlr_generated +GRAMMARS=SubstraitLexer.g4 TestFileLexer.g4 TestFileParser.g4 +OUTPUT_DIR=../tests/coverage/antlr_generated generate: java -jar $(ANTLR_JAR) -visitor -Dlanguage=Python3 -o $(OUTPUT_DIR) $(GRAMMARS) diff --git a/grammar/SubstraitLexer.g4 b/grammar/SubstraitLexer.g4 index 508721383..ba25bd6fe 100644 --- a/grammar/SubstraitLexer.g4 +++ b/grammar/SubstraitLexer.g4 @@ -112,7 +112,7 @@ QMARK: '?'; HASH: '#'; DOT: '.'; -STRING - : '\'' ('\\' . | '\'\'' | ~['\\])* '\'' - ; +//STRING +// : '\'' ('\\' . | '\'\'' | ~['\\])* '\'' +// ; diff --git a/grammar/SubstraitType.g4 b/grammar/SubstraitType.g4 index 9323a598e..27a238a8a 100644 --- a/grammar/SubstraitType.g4 +++ b/grammar/SubstraitType.g4 @@ -1,69 +1,11 @@ grammar SubstraitType; -// -fragment A : [aA]; -fragment B : [bB]; -fragment C : [cC]; -fragment D : [dD]; -fragment E : [eE]; -fragment F : [fF]; -fragment G : [gG]; -fragment H : [hH]; -fragment I : [iI]; -fragment J : [jJ]; -fragment K : [kK]; -fragment L : [lL]; -fragment M : [mM]; -fragment N : [nN]; -fragment O : [oO]; -fragment P : [pP]; -fragment Q : [qQ]; -fragment R : [rR]; -fragment S : [sS]; -fragment T : [tT]; -fragment U : [uU]; -fragment V : [vV]; -fragment W : [wW]; -fragment X : [xX]; -fragment Y : [yY]; -fragment Z : [zZ]; - +import SubstraitLexer; If : I F; Then : T H E N; Else : E L S E; -// TYPES -Boolean : B O O L E A N; -I8 : I '8'; -I16 : I '16'; -I32 : I '32'; -I64 : I '64'; -FP32 : F P '32'; -FP64 : F P '64'; -String : S T R I N G; -Binary : B I N A R Y; -Timestamp: T I M E S T A M P; -TimestampTZ: T I M E S T A M P '_' T Z; -Date : D A T E; -Time : T I M E; -IntervalYear: I N T E R V A L '_' Y E A R; -IntervalDay: I N T E R V A L '_' D A Y; -UUID : U U I D; -Decimal : D E C I M A L; -PrecisionTimestamp: P R E C I S I O N '_' T I M E S T A M P; -PrecisionTimestampTZ: P R E C I S I O N '_' T I M E S T A M P '_' T Z; -FixedChar: F I X E D C H A R; -VarChar : V A R C H A R; -FixedBinary: F I X E D B I N A R Y; -Struct : S T R U C T; -NStruct : N S T R U C T; -List : L I S T; -Map : M A P; -ANY : A N Y; -UserDefined: U '!'; - - // OPERATIONS And : A N D; Or : O R; @@ -165,16 +107,16 @@ scalarType ; parameterizedType - : FixedChar isnull='?'? Lt len=numericParameter Gt #fixedChar - | VarChar isnull='?'? Lt len=numericParameter Gt #varChar - | FixedBinary isnull='?'? Lt len=numericParameter Gt #fixedBinary - | Decimal isnull='?'? Lt precision=numericParameter Comma scale=numericParameter Gt #decimal - | PrecisionTimestamp isnull='?'? Lt precision=numericParameter Gt #precisionTimestamp - | PrecisionTimestampTZ isnull='?'? Lt precision=numericParameter Gt #precisionTimestampTZ - | Struct isnull='?'? Lt expr (Comma expr)* Gt #struct - | NStruct isnull='?'? Lt Identifier expr (Comma Identifier expr)* Gt #nStruct - | List isnull='?'? Lt expr Gt #list - | Map isnull='?'? Lt key=expr Comma value=expr Gt #map + : FixedChar isnull=QMark? Lt len=numericParameter Gt #fixedChar + | VarChar isnull=QMark? Lt len=numericParameter Gt #varChar + | FixedBinary isnull=QMark? Lt len=numericParameter Gt #fixedBinary + | Decimal isnull=QMark? Lt precision=numericParameter Comma scale=numericParameter Gt #decimal + | PrecisionTimestamp isnull=QMark? Lt precision=numericParameter Gt #precisionTimestamp + | PrecisionTimestampTZ isnull=QMark? Lt precision=numericParameter Gt #precisionTimestampTZ + | Struct isnull=QMark? Lt expr (Comma expr)* Gt #struct + | NStruct isnull=QMark? Lt Identifier expr (Comma Identifier expr)* Gt #nStruct + | List isnull=QMark? Lt expr Gt #list + | Map isnull=QMark? Lt key=expr Comma value=expr Gt #map ; numericParameter @@ -186,9 +128,9 @@ numericParameter anyType: ANY; type - : scalarType isnull='?'? + : scalarType isnull=QMark? | parameterizedType - | anyType isnull='?'? + | anyType isnull=QMark? ; // : (OParen innerExpr CParen | innerExpr) @@ -198,7 +140,7 @@ expr | Identifier Eq expr Newline+ (Identifier Eq expr Newline+)* finalType=type Newline* #MultilineDefinition | type #TypeLiteral | number=Number #LiteralNumber - | identifier=Identifier isnull='?'? #TypeParam + | identifier=Identifier isnull=QMark? #TypeParam | Identifier OParen (expr (Comma expr)*)? CParen #FunctionCall | left=expr op=(And | Or | Plus | Minus | Lt | Gt | Eq | NotEquals | Lte | Gte | Asterisk | ForwardSlash) right=expr #BinaryExpr | If ifExpr=expr Then thenExpr=expr Else elseExpr=expr #IfExpr diff --git a/grammar/TestFileLexer.g4 b/grammar/TestFileLexer.g4 index fa555518f..751e56285 100644 --- a/grammar/TestFileLexer.g4 +++ b/grammar/TestFileLexer.g4 @@ -2,7 +2,6 @@ lexer grammar TestFileLexer; import SubstraitLexer; - SUBSTRAIT_SCALAR_TEST : '### SUBSTRAIT_SCALAR_TEST:' ; @@ -36,9 +35,6 @@ SILENT: 'SILENT'; TIE_TO_EVEN: 'TIE_TO_EVEN'; NAN: 'NAN'; -STRING_LITERAL - : '\'' ('\\' . | '\'\'' | ~['\\])* '\'' - ; INTEGER_LITERAL : [+-]? INTEGER @@ -59,27 +55,25 @@ BOOLEAN_LITERAL : 'true' | 'false' ; - fragment FourDigits: [0-9][0-9][0-9][0-9]; fragment TwoDigits: [0-9][0-9]; -DATE_LITERAL - : '\'' FourDigits '-' TwoDigits '-' TwoDigits '\'' - ; - -TIME_LITERAL - : '\'' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? '\'' +TIMESTAMP_TZ_LITERAL + : '\'' FourDigits '-' TwoDigits '-' TwoDigits 'T' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? + [+-] TwoDigits ':' TwoDigits '\'' ; TIMESTAMP_LITERAL : '\'' FourDigits '-' TwoDigits '-' TwoDigits 'T' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? '\'' ; -TIMESTAMP_TZ_LITERAL - : '\'' FourDigits '-' TwoDigits '-' TwoDigits 'T' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? - [+-] TwoDigits ':' TwoDigits '\'' +TIME_LITERAL + : '\'' TwoDigits ':' TwoDigits ':' TwoDigits ( '.' [0-9]+ )? '\'' ; +DATE_LITERAL + : '\'' FourDigits '-' TwoDigits '-' TwoDigits '\'' + ; PERIOD_PREFIX: 'P'; TIME_PREFIX: 'T'; @@ -109,3 +103,7 @@ fragment TIME_INTERVAL ; NULL_LITERAL: 'null'; + +STRING_LITERAL + : '\'' ('\\' . | '\'\'' | ~['\\])* '\'' + ; diff --git a/grammar/TestFileParser.g4 b/grammar/TestFileParser.g4 index 002c58c68..8ce529ff2 100644 --- a/grammar/TestFileParser.g4 +++ b/grammar/TestFileParser.g4 @@ -1,7 +1,8 @@ parser grammar TestFileParser; options { - tokenVocab=TestFileLexer; // This imports the tokens from SubstraitLexer.g4 + tokenVocab=SubstraitLexer; + tokenVocab=TestFileLexer; } doc @@ -17,7 +18,7 @@ version ; include - : SUBSTRAIT_INCLUDE STRING (COMMA STRING)? + : SUBSTRAIT_INCLUDE STRING_LITERAL (COMMA STRING_LITERAL)? ; testGroup @@ -75,7 +76,7 @@ booleanArg ; stringArg - : STRING_LITERAL DOUBLE_COLON String + : STRING_LITERAL DOUBLE_COLON Str ; decimalArg @@ -93,19 +94,19 @@ timeArg ; timestampArg - : TIMESTAMP_LITERAL DOUBLE_COLON Timestamp + : TIMESTAMP_LITERAL DOUBLE_COLON Ts ; timestampTzArg - : TIMESTAMP_TZ_LITERAL DOUBLE_COLON TimestampTZ + : TIMESTAMP_TZ_LITERAL DOUBLE_COLON TsTZ ; intervalYearArg - : INTERVAL_YEAR_LITERAL DOUBLE_COLON IntervalYear + : INTERVAL_YEAR_LITERAL DOUBLE_COLON IYear ; intervalDayArg - : INTERVAL_DAY_LITERAL DOUBLE_COLON IntervalDay + : INTERVAL_DAY_LITERAL DOUBLE_COLON IDay ; intervalYearLiteral @@ -152,27 +153,27 @@ scalarType ; fixedCharType - : FixedChar isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #fixedChar + : FChar isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #fixedChar ; varCharType - : VarChar isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #varChar + : VChar isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #varChar ; fixedBinaryType - : FixedBinary isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #fixedBinary + : FBin isnull=QMARK? O_ANGLE_BRACKET len=numericParameter C_ANGLE_BRACKET #fixedBinary ; decimalType - : Decimal isnull=QMARK? (O_ANGLE_BRACKET precision=numericParameter COMMA scale=numericParameter C_ANGLE_BRACKET)? #decimal + : Dec isnull=QMARK? (O_ANGLE_BRACKET precision=numericParameter COMMA scale=numericParameter C_ANGLE_BRACKET)? #decimal ; precisionTimestampType - : PrecisionTimestamp isnull=QMARK? O_ANGLE_BRACKET precision=numericParameter C_ANGLE_BRACKET #precisionTimestamp + : PTs isnull=QMARK? O_ANGLE_BRACKET precision=numericParameter C_ANGLE_BRACKET #precisionTimestamp ; precisionTimestampTZType - : PrecisionTimestampTZ isnull=QMARK? O_ANGLE_BRACKET precision=numericParameter C_ANGLE_BRACKET #precisionTimestampTZ + : PTsTZ isnull=QMARK? O_ANGLE_BRACKET precision=numericParameter C_ANGLE_BRACKET #precisionTimestampTZ ; parameterizedType diff --git a/tests/cases/arithmetic/add.test b/tests/cases/arithmetic/add.test new file mode 100644 index 000000000..7d7c36a6d --- /dev/null +++ b/tests/cases/arithmetic/add.test @@ -0,0 +1,31 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/functions_arithmetic.yaml' + +# basic: Basic examples without any special cases +add(120::i8, 5::i8) = 125::i8 +add(100::i16, 100::i16) = 200::i16 +add(30000::i32, 30000::i32) = 60000::i32 +add(2000000000::i64, 2000000000::i64) = 4000000000::i64 + +# overflow: Examples demonstrating overflow behavior +add(120::i8, 10::i8) [overflow:ERROR] = +add(30000::i16, 30000::i16) [overflow:ERROR] = +add(2000000000::i32, 2000000000::i32) [overflow:ERROR] = +add(9223372036854775807::i64, 1::i64) [overflow:ERROR] = + +# overflow: Examples demonstrating overflow behavior tests: overflow with SATURATE +add(120::i8, 10::i8) [overflow:SATURATE] = 127::i8 +add(-120::i8, -10::i8) [overflow:SATURATE] = -128::i8 + +# overflow: Examples demonstrating overflow behavior tests: overflow with SILENT +add(120::i8, 10::i8) [overflow:SILENT] = + +# floating_exception: Examples demonstrating exceptional floating point cases +add(1.5e+308::fp64, 1.5e+308::fp64) = inf::fp64 +add(-1.5e+308::fp64, -1.5e+308::fp64) = -inf::fp64 + +# rounding: Examples demonstrating floating point rounding behavior +add(4.5::fp32, 2.500001::fp32) [rounding:TIE_TO_EVEN] = 7.000001::fp32 + +# types: Examples demonstrating behavior of different data types +add(4.5::fp64, 2.5000007152557373::fp64) = 7.00000071525573::fp64 diff --git a/tests/cases/arithmetic_decimal/power.test b/tests/cases/arithmetic_decimal/power.test new file mode 100644 index 000000000..a63508cfe --- /dev/null +++ b/tests/cases/arithmetic_decimal/power.test @@ -0,0 +1,21 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: 'extensions/functions_arithmetic_decimal.yaml' + +# basic: Basic examples without any special cases +power(8::dec, 2::dec<38, 0>) = 64::fp64 +power(1.0::dec, -1.0::dec<38, 0>) = 1.0::fp64 +power(2.0::dec<38, 0>, -2.0::dec<38, 0>) = 0.25::fp64 +power(13::dec<38, 0>, 10::dec<38, 0>) = 137858491849::fp64 + +# result_more_than_input_precison: Examples demonstrating result with more precision than input +power(16::dec<2, 0>, 4::dec<38, 0>) = 65536::fp64 + +# floating_exception: Examples demonstrating exceptional floating point cases +power(1.5e+10::dec<38, 0>, 1.5e+20::dec<38, 0>) = inf::fp64 +power(-16::dec<4, 0>, 1001::dec<4, 0>) = -inf::fp64 + +# complex_number: Examples demonstrating complex number output +power(-1::dec, 0.5::dec<38,1>) [complex_number_result:NAN] = nan::fp64 + +# complex_number: Examples demonstrating complex number output tests: complex_number_result with ERROR +power(-1::dec, 0.5::dec<38,1>) [complex_number_result:ERROR] = diff --git a/tests/cases/datetime/lt_datetime.test b/tests/cases/datetime/lt_datetime.test new file mode 100644 index 000000000..a2c14c44d --- /dev/null +++ b/tests/cases/datetime/lt_datetime.test @@ -0,0 +1,25 @@ +### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/functions_datetime.yaml' + +# timestamps: examples using the timestamp type +lt('2016-12-31T13:30:15'::ts, '2017-12-31T13:30:15'::ts) = true::bool +lt('2018-12-31T13:30:15'::ts, '2017-12-31T13:30:15'::ts) = false::bool + +# timestamp_tz: examples using the timestamp_tz type +lt('1999-01-08T01:05:05-08:00'::tstz, '1999-01-08T04:05:06-05:00'::tstz) = true::bool +lt('1999-01-08T01:05:06-08:00'::tstz, '1999-01-08T04:05:06-05:00'::tstz) = false::bool + +# date: examples using the date type +lt('2020-12-30'::date, '2020-12-31'::date) = true::bool +lt('2020-12-31'::date, '2020-12-30'::date) = false::bool + +# interval: examples using the interval type +lt('P7D'::iday, 'P6D'::iday) = false::bool +lt('P5D'::iday, 'P6D'::iday) = true::bool +lt('P5Y'::iyear, 'P6Y'::iyear) = true::bool +lt('P7Y'::iyear, 'P6Y'::iyear) = false::bool + +# null_input: examples with null args or return +lt(null::iday, 'P5D'::iday) = null::bool +lt(null::date, '2020-12-30'::date) = null::bool +lt(null::ts, '2018-12-31T13:30:15'::ts) = null::bool diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py new file mode 100755 index 000000000..6d4aabb19 --- /dev/null +++ b/tests/coverage/coverage.py @@ -0,0 +1,84 @@ +# SPDX-License-Identifier: Apache-2.0 + +from antlr4 import FileStream, InputStream, CommonTokenStream +from antlr_generated.TestFileLexer import TestFileLexer +from antlr4.error.ErrorListener import ErrorListener +from antlr_generated.TestFileParser import TestFileParser +from tests.coverage.visitor import TestCaseVisitor + + +def parse_one_file(file_path): + parse_stream(FileStream(file_path)) + + +def parse_string(input_string): + return parse_stream(InputStream(input_string)) + + +def parse_stream(input_stream): + # Create a lexer and parser + lexer = TestFileLexer(input_stream) + token_stream = CommonTokenStream(lexer) + parser = TestFileParser(token_stream) + + tree = parser.doc() # This is the entry point of testfile parser + if parser.getNumberOfSyntaxErrors() > 0: + print(tree.toStringTree(recog=parser)) + print(f"{parser.getNumberOfSyntaxErrors()} Syntax errors found, exiting") + return + + # Optionally, print the parse tree in LISP format + print(tree.toStringTree(recog=parser)) + + # TODO use custom visitor to build test cases and compute coverage + # visitor = TestCaseVisitor() + # visitor.visit(tree) + # tree.visit() + + +def parse_basic_example(): + parse_string( + """### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/functions_arithmetic.yaml' + +# basic: 'Basic examples without any special cases' +add(120::i8, 5::i8) = 125::i8 +add(100::i16, 100::i16) = 200::i16 + +# overflow: Examples demonstrating overflow behavior +add(120::i8, 10::i8) [overflow:ERROR] = +""" + ) + + +def parse_date_time_example(): + parse_string( + """### SUBSTRAIT_SCALAR_TEST: v1.0 + ### SUBSTRAIT_INCLUDE: '/extensions/functions_datetime.yaml' + +# timestamps: examples using the timestamp type +lt('2016-12-31T13:30:15'::ts, '2017-12-31T13:30:15'::ts) = true::bool +""" + ) + + +def parse_decimal_example(): + parse_string( + """### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: 'extensions/functions_arithmetic_decimal.yaml' + +# basic: Basic examples without any special cases +power(8::dec, 2::dec<38, 0>) = 64::fp64 +power(1.0::dec, -1.0::dec<38, 0>) = 1.0::fp64 +""" + ) + + +if __name__ == "__main__": + # TODO move these tests to test folder + # parse_basic_example() + parse_date_time_example() + # parse_decimal_example() + # parse_one_file("../cases/arithmetic/add.test") + # parse_one_file("../cases/datetime/lt_datetime.test") + # parse_one_file("../cases/arithmetic_decimal/power.test") diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py new file mode 100644 index 000000000..f1c4cfb39 --- /dev/null +++ b/tests/coverage/visitor.py @@ -0,0 +1,19 @@ +# SPDX-License-Identifier: Apache-2.0 +import sys +from antlr4 import * +from antlr_generated.TestFileParser import TestFileParser +from antlr_generated.TestFileParserVisitor import TestFileParserVisitor + + +class TestCaseVisitor(TestFileParserVisitor): + def visitDoc(self, ctx: TestFileParser.DocContext): + # TODO Implement this method + return int(ctx.getText()) + + def visitTestGroup(self, ctx: TestFileParser.TestGroupContext): + # TODO Implement this method + return self.visitChildren(ctx) + + def visitTestCase(self, ctx: TestFileParser.TestCaseContext): + # TODO Implement this method + return self.visitChildren(ctx) From feff8b3e8d2b5659e245cca02b878128ba97d0c5 Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Wed, 28 Aug 2024 21:02:49 +0530 Subject: [PATCH 03/19] Parser changes to parse a test file and populate TestCase in an object --- grammar/TestFileParser.g4 | 40 +- grammar/TypeDerivation.g4 | 612 ++++++++++++++++++++++ tests/cases/arithmetic_decimal/power.test | 4 +- tests/coverage/coverage.py | 70 +-- tests/coverage/nodes.py | 32 ++ tests/coverage/test_coverage.py | 80 +++ tests/coverage/visitor.py | 182 ++++++- 7 files changed, 940 insertions(+), 80 deletions(-) create mode 100644 grammar/TypeDerivation.g4 create mode 100644 tests/coverage/nodes.py create mode 100644 tests/coverage/test_coverage.py diff --git a/grammar/TestFileParser.g4 b/grammar/TestFileParser.g4 index 8ce529ff2..74e32255d 100644 --- a/grammar/TestFileParser.g4 +++ b/grammar/TestFileParser.g4 @@ -6,7 +6,7 @@ options { } doc - : header (testGroup? testCase+)+ EOF + : header testGroup+ EOF ; header @@ -18,10 +18,10 @@ version ; include - : SUBSTRAIT_INCLUDE STRING_LITERAL (COMMA STRING_LITERAL)? + : SUBSTRAIT_INCLUDE STRING_LITERAL (COMMA STRING_LITERAL)* ; -testGroup +testGroupDescription : DESCRIPTION_LINE ; @@ -29,6 +29,10 @@ testCase : functionName=IDENTIFIER OPAREN arguments CPAREN ( OBRACKET func_options CBRACKET )? EQ result ; +testGroup + : testGroupDescription (testCase)+ + ; + arguments : argument (COMMA argument)* ; @@ -53,6 +57,10 @@ argument | intervalDayArg ; +numericLiteral + : DECIMAL_LITERAL | INTEGER_LITERAL | FLOAT_LITERAL + ; + nullArg: NULL_LITERAL DOUBLE_COLON datatype; i8Arg: INTEGER_LITERAL DOUBLE_COLON I8; @@ -64,11 +72,15 @@ i32Arg: INTEGER_LITERAL DOUBLE_COLON I32; i64Arg: INTEGER_LITERAL DOUBLE_COLON I64; fp32Arg - : FLOAT_LITERAL DOUBLE_COLON FP32 + : numericLiteral DOUBLE_COLON FP32 ; fp64Arg - : FLOAT_LITERAL DOUBLE_COLON FP64 + : numericLiteral DOUBLE_COLON FP64 + ; + +decimalArg + : numericLiteral DOUBLE_COLON decimalType ; booleanArg @@ -79,12 +91,6 @@ stringArg : STRING_LITERAL DOUBLE_COLON Str ; -decimalArg - : DECIMAL_LITERAL DOUBLE_COLON (FP32 | FP64 | decimalType) - | INTEGER_LITERAL DOUBLE_COLON (FP32 | FP64 | decimalType) - | FLOAT_LITERAL DOUBLE_COLON decimalType - ; - dateArg : DATE_LITERAL DOUBLE_COLON Date ; @@ -140,14 +146,14 @@ scalarType | I64 #i64 | FP32 #fp32 | FP64 #fp64 - | String #string + | Str #string | Binary #binary - | Timestamp #timestamp - | TimestampTZ #timestampTz + | Ts #timestamp + | TsTZ #timestampTz | Date #date | Time #time - | IntervalDay #intervalDay - | IntervalYear #intervalYear + | IDay #intervalDay + | IYear #intervalYear | UUID #uuid | UserDefined IDENTIFIER #userDefined ; @@ -191,7 +197,7 @@ parameterizedType ; numericParameter - : INTEGER_LITERAL #numericLiteral + : INTEGER_LITERAL #integerLiteral ; substraitError diff --git a/grammar/TypeDerivation.g4 b/grammar/TypeDerivation.g4 new file mode 100644 index 000000000..a90e988d0 --- /dev/null +++ b/grammar/TypeDerivation.g4 @@ -0,0 +1,612 @@ +grammar TypeDerivation; + +// Note: this grammar is intentionally written to avoid ANTLR-specific features +// that someone who hasn't used ANTLR before might not know about, including +// explicitly avoiding left recursion, such that it can easily be ported to +// other parser generators if necessary. In this way, it hopefully doubles as a +// human-readable specification for this DSL. +// +// This comes at the cost of not generating very nice parse trees. You can use +// this grammar with ANTLR directly if you want, but you might want to rewrite +// it if you intend to use the listener or generated AST directly. +// +// Some things that you will need to know if you've never seen ANTLR before: +// - ANTLR distinguishes between tokenizer rules and parser rules by +// capitalization of the rule name: if the first letter is uppercase, the +// rule is a token rule; if it is lowercase, it is a parser rule. Yuck. +// - When multiple token rules match: +// - choose the token that matches the most text; +// - if same length, use the one defined earlier. +// (ANTLR supports implicit tokens as well, but we don't use them) +// - Parse conflicts are solved using PEG rules. That is, for alternations, +// the first alternative that matches the input is used. For ?, *, and +, +// matching is greedy. +// - The ~ symbol is used to negate character sets, as opposed to the [^...] +// syntax from regular expressions. + + +//============================================================================= +// Whitespace and comment tokens +//============================================================================= + +// Whitespace and comment handling. You can use C-style line and block +// comments. +LineComment : '//' ~[\r\n]* -> channel(HIDDEN) ; +BlockComment : ( '/*' ( ~'*' | '*'+ ~[*/] ) '*'* '*/' ) -> channel(HIDDEN) ; +Whitespace : [ \t]+ -> channel(HIDDEN) ; + +// Type derivations are newline-sensitive, so they're not ignored. +Newline : [\r\n]+ ; + +// Newlines can be embedded by escaping the newline character itself with a +// backslash. +EscNewline : '\\' [\r\n]+ -> channel(HIDDEN) ; + + +//============================================================================= +// Keyword tokens +//============================================================================= + +// Substrait is case-insensitive, ANTLR is not. So, in order to define our +// keywords in a somewhat readable way, we have to define these shortcuts. +// If you've never seen ANTLR before, fragment rules are pretty much just +// glorified preprocessor/search-and-replace macros. +fragment A : [aA]; fragment B : [bB]; fragment C : [cC]; fragment D : [dD]; +fragment E : [eE]; fragment F : [fF]; fragment G : [gG]; fragment H : [hH]; +fragment I : [iI]; fragment J : [jJ]; fragment K : [kK]; fragment L : [lL]; +fragment M : [mM]; fragment N : [nN]; fragment O : [oO]; fragment P : [pP]; +fragment Q : [qQ]; fragment R : [rR]; fragment S : [sS]; fragment T : [tT]; +fragment U : [uU]; fragment V : [vV]; fragment W : [wW]; fragment X : [xX]; +fragment Y : [yY]; fragment Z : [zZ]; + +// Syntactic keywords. +Assert : A S S E R T ; +Matches : M A T C H E S ; +If : I F ; +Then : T H E N ; +Else : E L S E ; + +// Named literal values. +Null : N U L L ; +True : T R U E ; +False : F A L S E ; + +// Metatype identification keywords. +Metabool : M E T A B O O L ; +Metaint : M E T A I N T ; +Metaenum : M E T A E N U M ; +Metastr : M E T A S T R ; +Typename : T Y P E N A M E ; + +// Note that data type classes are not keywords. We support user-defined type +// classes anyway, so name resolution has to be done after parsing anyway. + + +//============================================================================= +// Symbol tokens +//============================================================================= + +// Symbols used. +Period : '.' ; // identifier paths +Comma : ',' ; // separator for pattern lists +Colon : ':' ; // separator for named parameters +Semicolon : ';' ; // separator for statements +Question : '?' ; // any, inconsistent bindings & nullable type suffix +Bang : '!' ; // boolean NOT & explicitly non-nullable type suffix +OpenParen : '(' ; // precedence override & function call args (open) +CloseParen : ')' ; // precedence override & function call args (close) +OpenCurly : '{' ; // enum set patterns (open) +CloseCurly : '}' ; // enum set patterns (close) +OpenSquare : '[' ; // data type variation suffix (open) +CloseSquare : ']' ; // data type variation suffix (close) +Assign : '=' ; // assignment statements +BooleanOr : '||' ; // boolean OR expression +BooleanAnd : '&&' ; // boolean AND expression +Equal : '==' ; // equality expression +NotEqual : '!=' ; // not-equals expression +LessThan : '<' ; // less-than expression & data type parameter pack +LessEqual : '<=' ; // less-equal expression +GreaterThan : '>' ; // greater-than expression & data type parameter pack +GreaterEqual : '>=' ; // greater-equal expression +Plus : '+' ; // additions and integer literal sign +Minus : '-' ; // subtractions, negation, and integer literal sign +Multiply : '*' ; // multiplication expression +Divide : '/' ; // division expression +Range : '..' ; // integer set patterns + + +//============================================================================= +// Procedurally-matched tokens +//============================================================================= + +// Tokens for integer literals. +Nonzero : [1-9] [0-9]* ; +Zero : '0' ; + +// String literal token. +String : '"' ~["] '"' ; + +// Identifier token. Note that $ signs are legal in identifiers, and note that +// all identifier matching is case-insensitive. Note also that keywords take +// precedence. +Identifier : [a-zA-Z_$] [a-zA-Z0-9_$]* ; + + +//============================================================================= +// Grammar rules +//============================================================================= + +// Most things in the simple extension YAMLs that refer to a type are parsed +// using patterns; patterns can both matched and evaluated (not ALL patterns +// can do both, but there is considerable overlap between the two classes, +// so they were conceptually merged). When a type needs to be derived based on +// a number of given metavalues, such as the data types of arguments passed to +// a function, a derivation program is used. Syntactically, the only difference +// is that programs can include a set of statements before the final pattern. +// Newlines can optionally go before or after a type derivation pattern or +// program without affecting syntax. +startPattern : Whitespace* Newline* pattern Newline* EOF ; +startProgram : Whitespace* Newline* program Newline* EOF ; + +// A type derivation program consists of zero or more statements followed by +// the final pattern that should evaluate to the derived data type. +program : ( statement statementSeparator )* pattern ; + +// Statements are separated from each other and from the final derivation +// expression using newlines or a semicolon. +statementSeparator : Newline* ( Newline | Semicolon Newline* ) ; + +// Statements manipulate the state of the type derivation interpreter before +// the final derivation expression is evaluated. They look like assignment +// statements at first glance, but act more like equality or set containment +// assertions: the right-hand side is evaluated like an expression as you +// might expect, but the left-hand side acts just like the patterns that are +// used to match function argument types. While this is perhaps not the most +// intuitive ruleset, it is extremely easy to implement (it only reuses +// features we already needed anyway), while also being a much more powerful +// primitive than a simple assignment statement, because it can also be used +// for bounds checking and other assertions. For example, if we have a +// function like `fn(VARCHAR(a), VARCHAR(b))` and the implementation of the +// function requires that a + b equals 10, we can simply write "10 = a + b". +// This works, because the pattern "10" will only match the value 10, and +// a pattern mismatch at any point during the matching and evaluation process +// indicates that the implementation is incompatible with the given argument +// types. If you find this syntax confusing, you may also write +// "assert a + b matches 10" or "assert a + b == 10"; the former does the +// exact same thing, while the latter reduces to "true = a + b == 10", which is +// functionally the same thing. +// +// Note that when you use these statements like assignment statements, you can +// only ever reassign a binding to the same value. For example, "a = 10; a = 20" +// will always fail, because a cannot both be 10 and 20 at the same time (more +// accurately, a is bound to 10, so the second statement behaves like +// "10 = 20", and 20 does not match 10). +statement + : pattern Assign pattern #Normal + | Assert pattern Matches pattern #Match + | Assert pattern #Assert + ; + +// Patterns are at the core of the type derivation interpreter; they are used +// both for matching and as expressions. However, note that not all types of +// patterns work in both contexts. +pattern : patternInvalidIfThenElse ; + +patternInvalidIfThenElse + : patternOr #ValidPattern + + // The following rule is ILLEGAL and only exists for better error recovery + // in the validator. It's an incomplete implementation of a C-style + // if-then-else, which should be written as "if x then y else z" instead. + // The reason is that this rule makes question marks HEAVILY ambiguous. + // ANTLR can sort of deal with this because it implements a PEG parser + // and will thus attempt the above option first, but many parser frameworks + // won't handle this correctly, and parsing will be slow. Hence the + // non-standard syntax. The validator supports this nonetheless because some + // core extensions are using C-style if-then-else at the time of writing, and + // the documentation is rather ambiguous about which it should be. + | patternOr Question patternOr Colon pattern #InvalidIfThenElse + ; + +// Lazily-evaluated boolean OR expression. Maps to builtin or() function if +// more than one pattern is parsed. +patternOr : patternAnd ( operatorOr patternAnd )* ; +operatorOr : BooleanOr #Or ; + +// Lazily-evaluated boolean AND expression. Maps to builtin and() function if +// more than one pattern is parsed. +patternAnd : patternEqNeq ( operatorAnd patternEqNeq )* ; +operatorAnd : BooleanAnd #And ; + +// Equality and not-equality expressions. These map to the builtin equal() +// and not_equal() functions in left-to-right order. +patternEqNeq : patternIneq ( operatorEqNeq patternIneq )* ; +operatorEqNeq : Equal #Eq | NotEqual #Neq ; + +// Integer inequality expressions. These map to the builtin greater_than(), +// less_than(), greater_equal(), and less_equal() functions in left-to-right +// order. +patternIneq : patternAddSub ( operatorIneq patternAddSub )* ; +operatorIneq : LessThan #Lt | LessEqual #Le | GreaterThan #Gt | GreaterEqual #Ge ; + +// Integer addition and subtraction. These map to the builtin add() and +// subtract() functions in left-to-right order. +patternAddSub : patternMulDiv ( operatorAddSub patternMulDiv )* ; +operatorAddSub : Plus #Add | Minus #Sub ; + +// Integer multiplication and division. These map to the builtin multiply() and +// divide() functions in left-to-right order. +patternMulDiv : patternMisc ( operatorMulDiv patternMisc )* ; +operatorMulDiv : Multiply #Mul | Divide #Div ; + +// Miscellaneous patterns that don't need special rules for precedence or +// avoiding left-recursion. +patternMisc + + // Parentheses for overriding operator precedence. + : OpenParen pattern CloseParen #parentheses + + // If-then-else pattern. Can only be evaluated. The first pattern must + // evaluate to a boolean. The second or third pattern is then evaluated + // based on that boolean and returned. The branch that is not selected is + // also not evaluated (i.e. evaluation is lazy). + | If pattern Then pattern Else pattern #ifThenElse + + // Unary not function. Can only be evaluated and can only be applied to + // booleans. + | Bang pattern #unaryNot + + // The "anything" pattern. This matches everything, and cannot be evaluated. + // It's primarily intended for matching (parts of) argument types, when you + // don't need or want a binding. For example, `equals(?, ?) -> boolean` would + // allow for any combination of argument types. This distinguishes it from + // `equals(any1, any1) -> boolean`, which only accepts equal types; instead + // it behaves like `equals(any1, any2) -> boolean`. `?` is especially useful + // when you want this type of behavior for a variadic function; for example, + // `serialize(?...) -> binary` will match any number and combination of + // argument types, while `serialize(any1...) -> binary` would only accept any + // number of any *one* data type. + | Question #any + + // Matches any boolean value. Cannot be evaluated. + | Metabool #boolAny + + // Matches and evaluates to the boolean value "true". + | True #boolTrue + + // Matches and evaluates to the boolean value "false". + | False #boolFalse + + // Matches any integer value. Cannot be evaluated. + | Metaint #intAny + + // Matches any integer value within the specified inclusive range. Can only + // be evaluated if the two bounds are equal, in which case it reduces to just + // a single integer. + | integer Range integer #intRange + + // Matches any integer value that equals at least the given number. Cannot be + // evaluated. + | integer Range #intAtLeast + + // Matches any integer value that equals at most the given number. Cannot be + // evaluated. + | Range integer #intAtMost + + // Matches and evaluates to exactly the given integer. + | integer #intExactly + + // Matches any enumeration constant. + | Metaenum #enumAny + + // Matches an enumeration constant in the given set. If only a single + // constant is specified, the pattern evaluates to that constant, otherwise + // it cannot be evaluated. + | OpenCurly Identifier (Comma Identifier)* CloseCurly #enumSet + + // Matches any string. + | Metastr #strAny + + // Matches and evaluates to exactly the given string. + | String #strExactly + + // Matches any typename for which the nullability matches the nullability + // suffix. Use `typename??` for either nullability. + | Typename nullability? #dtAny + + // Evaluates a function. When a function is used in match context, the + // function (and its arguments) will be *evaluated* instead, and the incoming + // value is matched against the result. This means that it is legal to define + // a function like f(VARCHAR(x), VARCHAR(y), VARCHAR(x + y)) because the x + // and y bindings are captured before x + y is evaluated, but it is NOT legal + // to define it like f(VARCHAR(x + y), VARCHAR(x), VARCHAR(y)) because x and + // y are not yet bound when x + y is evaluated. + // f(VARCHAR(x), VARCHAR(x + y), VARCHAR(y)) is also NOT legal, again because + // some of the function bindings have not yet been captured, even though + // mathematically this could be rewritten from x + y <- input to + // y <= input - x (the evaluator is not smart enough for this, and this + // rewriting cannot be generalized over all functions). + // + // The following functions are currently available: + // + // - "not(metabool) -> metabool": boolean NOT. + // - "and(metabool*) -> metabool": boolean AND. Evaluated lazily from left + // to right. + // - "or(metabool*) -> metabool": boolean OR. Evaluated lazily from left to + // right. + // - "negate(metaint) -> metaint": integer negation. 64-bit two's complement + // overflow must be detected, and implies that the function implementation + // that the program belongs to does not match the given argument types. + // - "add(metaint*) -> metaint": integer sum. Overflow handled as above. + // - "subtract(metaint, metaint) -> metaint": subtracts an integer from + // another. Overflow handled as above. + // - "multiply(metaint*) -> metaint": integer product. Overflow handled as + // above. + // - "divide(metaint, metaint) -> metaint": divides an integer over + // another. Overflow and division by zero handled as above. + // - "min(metaint+) -> metaint": return the minimum integer value. + // - "max(metaint+) -> metaint": return the maximum integer value. + // - "equal(T, T) -> metabool": return whether the two values are equal. + // - "not_equal(T, T) -> metabool": return whether the two values are not + // equal. + // - "greater_than(metaint, metaint) -> metabool": return whether the left + // integer is greater than the right. + // - "less_than(metaint, metaint) -> metabool": return whether the left + // integer is less than the right. + // - "greater_equal(metaint, metaint) -> metabool": return whether the left + // integer is greater than or equal to the right. + // - "less_equal(metaint, metaint) -> metabool": return whether the left + // integer is less than or equal to the right. + // - "covers(value, pattern) -> metabool": return whether the left value + // matches the pattern. The pattern may make use of bindings that were + // previously defined. New bindings are captured if and only if covers + // returns true. This allows for patterns like + // assert if covers(x, struct) then a < 10 \ + // else if covers(x, struct) then a + b < 10 \ + // else false; + // to be written and work as expected. + // - "if_then_else(metabool, T, T) -> T": if-then-else expression. Evaluated + // lazily. + // + // Note that many of the functions also have corresponding expressions. These + // expressions are simply syntactic sugar for calling the functions directly. + | Identifier OpenParen ( pattern (Comma pattern)* )? CloseParen #function + + // This pattern matches one of three things, which are too context-sensitive + // to distinguish at this time: + // + // - a data type pattern; + // - an enum constant; + // - a normal binding; or + // - a binding with nullability override. + // + // The type depends on the identifier path, and must be disambiguated as + // follows during name resolution: + // + // - Keep track of a case-insensitive mapping from name to binding, enum + // constant, or type class while analyzing the parse tree. It will be + // empty initially. + // - Whenever this pattern appears, resolve the name using this mapping: + // - If resolution fails, resolve the name as a type class instead (it + // could be the name of a builtin type class, a type class defined + // in the current extension, or a type class defined in a dependency + // if appropriately prefixed with the dependency namespace): + // - If this succeeds, add an entry to the name mapping, mapping the + // incoming identifier path to the type class. If the type class is + // user-defined, and the type class has enum parameter slots, also + // add entries to the name mapping for all the enum variants; if a + // name was already defined, do NOT update the mapping. Finally, + // disambiguate the pattern as a data type pattern. + // - If this fails and the identifier path consists of only a single + // element, map the incoming identifier path to a binding, and + // disambiguate the pattern as a normal binding or a binding + // with nullability override, depending on the presence of the + // nullability field. + // - If the above fails and the identifier path consists of multiple + // elements, analysis should fail. + // - If resolution yields a binding, disambiguate the pattern as a + // normal binding or a binding with nullability override, depending on + // the presence of the nullability field. + // - If resolution yields an enum constant, disambiguate the pattern as + // an enum constant. + // - If resolution yields a type class, disambiguate the pattern as a + // data type pattern. + // + // If the optional nullability, variation, or parameters fields are non-empty + // when they can't be according to the rules of the disambiguated pattern + // type, analysis should fail. + // + // Note that the `!` suffix disambiguates between a normal binding and a + // binding with a non-nullable nullability override. For a data type pattern, + // non-nullable is the default, so something like `i32` is exactly the same + // as `i32!`. + // + // The behavior for the resolved pattern types is: + // - Data type pattern: + // - Matches a metavalue if and only if: + // - the metavalue is a typename; + // - the type class matches the identified class; + // - the nullability of the type matches the rules detailed in the + // comments of the nullability rule; + // - the variation of the type matches the rules detailed in the + // comments of the variation rule; and + // - the parameter pack matches the rules detailed in the comments + // of the parameters rule. + // - Evaluates to a data type with the specified type class and the + // evaluation result of the nullability, variation, and parameters + // fields. If any of those things cannot be evaluated, the data type + // pattern cannot be evaluated. If any parameter pack constraint + // violations result from this, they are treated as pattern match + // failures (i.e., if this happens in a return type derivation of + // a function, the function is said to not match the given arguments). + // + // - Enum constant: + // - Matches a metavalue if and only if it is exactly the specified enum + // variant. + // - Evaluates to the specified enum variant. + // - The nullability, variation, and parameters fields are illegal and + // must be blank. + // + // - Consistent binding without nullability suffix: + // - If this is the first use of the name, matches non-typename + // metavalues and non-nullable typenames. The incoming metavalue is + // bound to the name as a side effect. + // - If the name was previously bound, matches only if the incoming + // metavalue is exactly equal to the previous binding. + // - Can only be evaluated if the name was previously bound, in which + // case it yields the bound value exactly. + // - The variation and parameter pack fields are illegal and must be + // blank. + // + // - Consistent binding with nullability suffix: + // - If this is the first use of the name, matches if and only if: + // - the incoming metavalue is a typename; and + // - the nullability of the incoming type matches the nullability + // suffix. + // If the above rules match, the incoming typename, with its + // nullability overridden to non-nullable, is bound to the name as a + // side effect. + // - If the name was previously bound, matches if and only if: + // - the incoming metavalue is a typename; + // - the nullability of the incoming type matches the nullability + // suffix; + // - the previously bound metavalue is a typename; and + // - the incoming type matches the previously bound type, ignoring + // nullability and parameter names. + // - Can only be evaluated if the name was previously bound. If the + // previously bound metavalue is not a typename, evaluation fails. The + // returned type is the previously bound type, with its nullability + // adjusted according to the nullability suffix evaluation rules. + // - The variation and parameters fields are illegal and must be blank. + | identifierPath nullability? variation? parameters? #datatypeBindingOrConstant + + // Pattern for inconsistent bindings. Inconsistent bindings are variations + // of normal bindings and bindings with nullability override with looser + // matching and extended evaluation rules. These rules are designed + // specifically for matching inconsistent variadic arguments and for + // modelling MIRROR nullability behavior. Specifically: + // + // - Use `?T` instead of `T` for a variadic argument slot to capture the + // value of the first argument and ignore the rest, thus rendering it + // inconsistent. + // - Use `type??nullable` instead of `type` for argument slots and the + // return type to match both nullable and non-nullable data types for + // the argument, and yield a nullable return type only if any of the + // bound arguments are nullable. + // + // The exacty behavior for the pattern types is as follows. Rules that differ + // from the consistent binding rules are highlighted with (!). + // + // - Inconsistent binding without nullability suffix: + // - If this is the first use of the name, matches non-typename + // metavalues and non-nullable typenames. The incoming metavalue is + // bound to the name as a side effect. + // - (!) If the name was previously bound, still matches all + // non-typename metavalues and non-nullable typenames. If the + // incoming metavalue is boolean `true`, and the currently bound + // metavalue is boolean `false`, rebind the name to `true` as a side + // effect. Otherwise, leave it unchanged. + // - (!) If this is the first use of the name, evaluation yields + // the metabool `false` (for the nullability of the return type in + // a MIRROR function). + // - If the name was previously bound, evaluation yields the bound + // value exactly. + // + // - Inconsistent binding with nullability override: + // - If this is the first use of the name, matches if and only if: + // - the incoming metavalue is a typename; and + // - the nullability of the incoming type matches the nullability + // field. + // If the above rules match, the incoming typename, with its + // nullability overridden to non-nullable, is bound to the name as a + // side effect. + // - (!) If the binding was previously bound, matches if and only if: + // - the incoming metavalue is a typename; and + // - the nullability of the incoming type matches the nullability + // field. + // There are no side effects in this case. + // - Can only be evaluated if the name was previously bound. If the + // previously bound metavalue is not a typename, evaluation fails. The + // returned type is the previously bound type, with its nullability + // adjusted according to the nullability field evaluation rules. + | Question Identifier nullability? #inconsistent + + // Unary negation function. Can only be evaluated and can only be applied to + // integers. Note that this is all the way at the back because signed integer + // literals should be preferred, since those can also be matched, and can + // deal with -2^63 without overflow. + | Minus pattern #unaryNegate + ; + +// Nullability suffix. +// +// - If there is no such suffix, or the suffix is "!", the pattern matches +// only non-nullable types, and also evaluates to a non-nullable type if +// applicable. The "!" suffix changes the semantics of bindings slightly +// compared to no suffix (specifically, `x!` only matches non-nullable +// typenames, but `x` also matches non-typename metavalues), but is +// otherwise optional and customarily not written. +// - If this suffix is just "?", the pattern matches only nullable types, +// and also evaluates to a nullable type if applicable. +// - If this suffix is a "?" followed by a pattern, the pattern is matched +// against false for non-nullable and true for nullable types. Likewise for +// evaluation; if the pattern evaluates to false the type will be +// non-nullable, if it evaluates to true it will be nullable. +nullability + : Bang #nonNullable + | Question #nullable + | Question pattern #nullableIf + ; + +// Type variation suffix. +// +// - If there is no such suffix, the pattern matches any variation that is +// marked as compatible with the system-preferred variation via the function +// behavior option of the variation, as well as the system-preferred +// variation itself. It will evaluate to the system-preferred variation. +// - If the suffix is [?], the pattern matches any variation, and cannot be +// evaluated. +// - If the suffix is [0], the pattern matches and evaluates to the +// system-preferred variation exactly. +// - If the suffix is [ident], the pattern matches and evaluates to the named +// variation exactly. The variation must be in scope. +variation : OpenSquare variationBody CloseSquare ; +variationBody + : Question #varAny + | Zero #varSystemPreferred + | identifierPath #varUserDefined + ; + +// Type parameter pack suffix. +// +// - If there is no such suffix, the pattern accepts any number of parameters +// for the type (assuming that the type class accepts this as well), and +// will attempt to evaluate to a type with no parameters. +// - If there is a "<>" suffix, the pattern accepts only types with zero +// parameters, and will attempt to evaluate to a type with no parameters. +// - If parameters are specified, the pattern accepts only types with exactly +// the specified number of parameters, and will attempt to evaluate to a +// type with exactly those parameters. +parameters : LessThan ( parameter (Comma parameter)* )? GreaterThan ; + +// Type parameter pattern. The name prefix is only used when evaluated (it is +// never matched), and is currently only accepted by the NSTRUCT (pseudo)type. +parameter : ( identifierOrString Colon )? parameterValue ; + +// A pattern for matching potentially-optional parameter values. "null" may be +// used to match or evaluate to explicitly-skipped optional parameters; +// otherwise, the given pattern is used for the parameter value. The "?" (any) +// pattern is special-cased to also match explicitly-skipped parameter slots. +parameterValue : Null #Null | pattern #Specified; + +// Integer literals. +integer : ( Plus | Minus )? ( Zero | Nonzero ) ; + +// When identifying user-defined types and variations, period-separated +// namespace paths are supported. +identifierPath : ( Identifier Period )* Identifier ; + +// The names of parameters (i.e. NSTRUCT field names) can be specified using +// both identifiers and strings. The latter is idiomatic only when the field +// name is not a valid Substrait identifier. +identifierOrString : String #Str | Identifier #Ident; diff --git a/tests/cases/arithmetic_decimal/power.test b/tests/cases/arithmetic_decimal/power.test index a63508cfe..37a0712d5 100644 --- a/tests/cases/arithmetic_decimal/power.test +++ b/tests/cases/arithmetic_decimal/power.test @@ -2,8 +2,8 @@ ### SUBSTRAIT_INCLUDE: 'extensions/functions_arithmetic_decimal.yaml' # basic: Basic examples without any special cases -power(8::dec, 2::dec<38, 0>) = 64::fp64 -power(1.0::dec, -1.0::dec<38, 0>) = 1.0::fp64 +power(8::dec<38, 0>, 2::dec<38, 0>) = 64::fp64 +power(1.0::dec<38, 0>, -1.0::dec<38, 0>) = 1.0::fp64 power(2.0::dec<38, 0>, -2.0::dec<38, 0>) = 0.25::fp64 power(13::dec<38, 0>, 10::dec<38, 0>) = 137858491849::fp64 diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index 6d4aabb19..053b3ad02 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -1,18 +1,14 @@ # SPDX-License-Identifier: Apache-2.0 +import os from antlr4 import FileStream, InputStream, CommonTokenStream -from antlr_generated.TestFileLexer import TestFileLexer -from antlr4.error.ErrorListener import ErrorListener -from antlr_generated.TestFileParser import TestFileParser +from tests.coverage.antlr_generated.TestFileLexer import TestFileLexer +from tests.coverage.antlr_generated.TestFileParser import TestFileParser from tests.coverage.visitor import TestCaseVisitor def parse_one_file(file_path): - parse_stream(FileStream(file_path)) - - -def parse_string(input_string): - return parse_stream(InputStream(input_string)) + return parse_stream(FileStream(file_path)) def parse_stream(input_stream): @@ -31,54 +27,22 @@ def parse_stream(input_stream): print(tree.toStringTree(recog=parser)) # TODO use custom visitor to build test cases and compute coverage - # visitor = TestCaseVisitor() - # visitor.visit(tree) - # tree.visit() - - -def parse_basic_example(): - parse_string( - """### SUBSTRAIT_SCALAR_TEST: v1.0 -### SUBSTRAIT_INCLUDE: '/extensions/functions_arithmetic.yaml' - -# basic: 'Basic examples without any special cases' -add(120::i8, 5::i8) = 125::i8 -add(100::i16, 100::i16) = 200::i16 - -# overflow: Examples demonstrating overflow behavior -add(120::i8, 10::i8) [overflow:ERROR] = -""" - ) - - -def parse_date_time_example(): - parse_string( - """### SUBSTRAIT_SCALAR_TEST: v1.0 - ### SUBSTRAIT_INCLUDE: '/extensions/functions_datetime.yaml' - -# timestamps: examples using the timestamp type -lt('2016-12-31T13:30:15'::ts, '2017-12-31T13:30:15'::ts) = true::bool -""" - ) - + visitor = TestCaseVisitor() + test_file = visitor.visit(tree) + return test_file -def parse_decimal_example(): - parse_string( - """### SUBSTRAIT_SCALAR_TEST: v1.0 -### SUBSTRAIT_INCLUDE: 'extensions/functions_arithmetic_decimal.yaml' -# basic: Basic examples without any special cases -power(8::dec, 2::dec<38, 0>) = 64::fp64 -power(1.0::dec, -1.0::dec<38, 0>) = 1.0::fp64 -""" - ) +def parse_directory_recursively(dirPath): + # for each file in directory call parse_one_file + test_files = [] + for file in os.listdir(dirPath): + if os.path.isfile(file) and file.endswith(".test"): + test_file = parse_one_file(file) + test_files.append(test_file) + elif os.path.isdir(file): + parse_directory_recursively(file) if __name__ == "__main__": # TODO move these tests to test folder - # parse_basic_example() - parse_date_time_example() - # parse_decimal_example() - # parse_one_file("../cases/arithmetic/add.test") - # parse_one_file("../cases/datetime/lt_datetime.test") - # parse_one_file("../cases/arithmetic_decimal/power.test") + parse_directory_recursively("../cases") diff --git a/tests/coverage/nodes.py b/tests/coverage/nodes.py new file mode 100644 index 000000000..66919c9a4 --- /dev/null +++ b/tests/coverage/nodes.py @@ -0,0 +1,32 @@ +from dataclasses import dataclass +from typing import List + + +@dataclass +class CaseGroup: + name: str + description: str + + +@dataclass +class CaseLiteral: + value: str | int | float | list + type: str + + +@dataclass +class TestCase: + function: str + base_uri: str + group: CaseGroup + options: dict + args: List[CaseLiteral] + result: CaseLiteral | str + comment: str + + +@dataclass +class TestFile: + version: str + include: str + testcases: List[TestCase] diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py new file mode 100644 index 000000000..1410766de --- /dev/null +++ b/tests/coverage/test_coverage.py @@ -0,0 +1,80 @@ +from antlr4 import InputStream +from tests.coverage.coverage import parse_stream, parse_one_file +from tests.coverage.nodes import CaseLiteral + + +def parse_string(input_string): + return parse_stream(InputStream(input_string)) + + +def test_parse_basic_example(): + test_file = parse_string( + """### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: '/extensions/functions_arithmetic.yaml' + +# basic: 'Basic examples without any special cases' +add(120::i8, 5::i8) = 125::i8 +add(100::i16, 100::i16) = 200::i16 + +# overflow: Examples demonstrating overflow behavior +add(120::i8, 10::i8) [overflow:ERROR] = +""" + ) + assert len(test_file.testcases) == 3 + + +def test_parse_date_time_example(): + test_file = parse_string( + """### SUBSTRAIT_SCALAR_TEST: v1.0 + ### SUBSTRAIT_INCLUDE: '/extensions/functions_datetime.yaml' + +# timestamps: examples using the timestamp type +lt('2016-12-31T13:30:15'::ts, '2017-12-31T13:30:15'::ts) = true::bool +""" + ) + assert len(test_file.testcases) == 1 + assert test_file.testcases[0].function == "lt" + assert test_file.testcases[0].base_uri == "/extensions/functions_datetime.yaml" + assert test_file.testcases[0].group.name == "timestamps" + assert test_file.testcases[0].group.description == "examples using the timestamp type" + assert test_file.testcases[0].result == CaseLiteral('true', "bool") + assert test_file.testcases[0].args[0] == CaseLiteral('2016-12-31T13:30:15', "ts") + assert test_file.testcases[0].args[1] == CaseLiteral('2017-12-31T13:30:15', "ts") + + +def test_parse_decimal_example(): + test_file = parse_string( + """### SUBSTRAIT_SCALAR_TEST: v1.0 +### SUBSTRAIT_INCLUDE: 'extensions/functions_arithmetic_decimal.yaml' + +# basic: Basic examples without any special cases +power(8::dec<38,0>, 2::dec<38, 0>) = 64::fp64 +power(1.0::dec<38, 0>, -1.0::dec<38, 0>) = 1.0::fp64 +""" + ) + assert len(test_file.testcases) == 2 + assert test_file.testcases[0].function == "power" + assert test_file.testcases[0].base_uri == "extensions/functions_arithmetic_decimal.yaml" + assert test_file.testcases[0].group.name == "basic" + assert test_file.testcases[0].group.description == "Basic examples without any special cases" + assert test_file.testcases[0].result == CaseLiteral('64', "fp64") + assert test_file.testcases[0].args[0] == CaseLiteral('8', "dec<38,0>") + assert test_file.testcases[0].args[1] == CaseLiteral('2', "dec<38,0>") + + +def test_parse_file(): + test_file = parse_one_file("../cases/arithmetic/add.test") + assert len(test_file.testcases) == 15 + assert test_file.testcases[0].function == "add" + assert test_file.testcases[0].base_uri == "/extensions/functions_arithmetic.yaml" + assert test_file.include == "/extensions/functions_arithmetic.yaml" + + test_file = parse_one_file("../cases/datetime/lt_datetime.test") + assert len(test_file.testcases) == 13 + assert test_file.testcases[0].function == "lt" + assert test_file.testcases[0].base_uri == "/extensions/functions_datetime.yaml" + + test_file = parse_one_file("../cases/arithmetic_decimal/power.test") + assert len(test_file.testcases) == 9 + assert test_file.testcases[0].function == "power" + assert test_file.testcases[0].base_uri == "extensions/functions_arithmetic_decimal.yaml" diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index f1c4cfb39..8afc8827c 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -1,19 +1,185 @@ # SPDX-License-Identifier: Apache-2.0 -import sys -from antlr4 import * -from antlr_generated.TestFileParser import TestFileParser -from antlr_generated.TestFileParserVisitor import TestFileParserVisitor +from tests.coverage.antlr_generated.TestFileParser import TestFileParser +from tests.coverage.antlr_generated.TestFileParserVisitor import TestFileParserVisitor +from tests.coverage.nodes import CaseGroup, TestFile, TestCase, CaseLiteral class TestCaseVisitor(TestFileParserVisitor): def visitDoc(self, ctx: TestFileParser.DocContext): # TODO Implement this method - return int(ctx.getText()) + version, include = self.visitHeader(ctx.header()) + testcases = [] + for group in ctx.testGroup(): + _, group_tests = self.visitTestGroup(group) + for test_case in group_tests: + test_case.base_uri = include + testcases.extend(group_tests) + + return TestFile(version, include, testcases) + + def visitHeader(self, ctx: TestFileParser.HeaderContext): + version = self.visitVersion(ctx.version()) + include = self.visitInclude(ctx.include()) + return version, include + + def visitVersion(self, ctx: TestFileParser.VersionContext): + return ctx.FORMAT_VERSION().getText() + + def visitInclude(self, ctx: TestFileParser.IncludeContext): + # TODO handle multiple includes + return ctx.STRING_LITERAL(0).getText().strip("'") + + def visitTestGroupDescription(self, ctx: TestFileParser.TestGroupDescriptionContext): + group = ctx.DESCRIPTION_LINE().getText().strip("#").strip() + parts = group.split(":") + if len(parts) == 2: + return CaseGroup(parts[0].strip(), parts[1].strip()) + + return CaseGroup(group, "") def visitTestGroup(self, ctx: TestFileParser.TestGroupContext): - # TODO Implement this method - return self.visitChildren(ctx) + group = self.visitTestGroupDescription(ctx.testGroupDescription()) + test_cases = [] + for test_case in ctx.testCase(): + testcase = self.visitTestCase(test_case) + testcase.group = group + test_cases.append(testcase) + return group, test_cases def visitTestCase(self, ctx: TestFileParser.TestCaseContext): # TODO Implement this method - return self.visitChildren(ctx) + args = self.visitArguments(ctx.arguments()) + result = self.visitResult(ctx.result()) + options = dict() + if ctx.func_options() is not None: + options = self.visitFunc_options(ctx.func_options()) + return TestCase(function=ctx.IDENTIFIER().getText(), + base_uri="", + group=None, + options=options, + args=args, + result=result, + comment="") + + def visitFunc_options(self, ctx: TestFileParser.Func_optionsContext): + options = {} + for option in ctx.func_option(): + key, value = self.visitFunc_option(option) + options[key] = value + return options + + def visitFunc_option(self, ctx: TestFileParser.Func_optionContext): + key = ctx.option_name().getText() + value = ctx.option_value().getText() + return key, value + + def visitArguments(self, ctx: TestFileParser.ArgumentsContext): + arguments = [] + for arg in ctx.argument(): + arguments.append(self.visitArgument(arg)) + return arguments + + def visitArgument(self, ctx: TestFileParser.ArgumentContext): + if ctx.i8Arg() is not None: + return self.visitI8Arg(ctx.i8Arg()) + if ctx.i16Arg() is not None: + return self.visitI16Arg(ctx.i16Arg()) + if ctx.i32Arg() is not None: + return self.visitI32Arg(ctx.i32Arg()) + if ctx.i64Arg() is not None: + return self.visitI64Arg(ctx.i64Arg()) + if ctx.fp32Arg() is not None: + return self.visitFp32Arg(ctx.fp32Arg()) + if ctx.fp64Arg() is not None: + return self.visitFp64Arg(ctx.fp64Arg()) + if ctx.booleanArg() is not None: + return self.visitBooleanArg(ctx.booleanArg()) + if ctx.stringArg() is not None: + return self.visitStringArg(ctx.stringArg()) + if ctx.decimalArg() is not None: + return self.visitDecimalArg(ctx.decimalArg()) + if ctx.dateArg() is not None: + return self.visitDateArg(ctx.dateArg()) + if ctx.timeArg() is not None: + return self.visitTimeArg(ctx.timeArg()) + if ctx.timestampArg() is not None: + return self.visitTimestampArg(ctx.timestampArg()) + if ctx.timestampTzArg() is not None: + return self.visitTimestampTzArg(ctx.timestampTzArg()) + if ctx.intervalDayArg() is not None: + return self.visitIntervalDayArg(ctx.intervalDayArg()) + if ctx.intervalYearArg() is not None: + return self.visitIntervalYearArg(ctx.intervalYearArg()) + if ctx.nullArg() is not None: + return self.visitNullArg(ctx.nullArg()) + + return CaseLiteral(value="unknown_value", type="unknown_type") + + def visitNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + if ctx.INTEGER_LITERAL() is not None: + return ctx.INTEGER_LITERAL().getText() + if ctx.DECIMAL_LITERAL() is not None: + return ctx.DECIMAL_LITERAL().getText() + return ctx.FLOAT_LITERAL + + def visitNullArg(self, ctx: TestFileParser.NullArgContext): + datatype = ctx.datatype().getText() + return CaseLiteral(value=None, type=datatype) + + def visitI8Arg(self, ctx: TestFileParser.I8ArgContext): + return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i8") + + def visitI16Arg(self, ctx: TestFileParser.I16ArgContext): + return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i16") + + def visitI32Arg(self, ctx: TestFileParser.I32ArgContext): + return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i32") + + def visitI64Arg(self, ctx: TestFileParser.I64ArgContext): + return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i64") + + def visitFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): + # TODO add checks on number of decimal places + return CaseLiteral(value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.FP32().getText().lower()) + + def visitFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): + return CaseLiteral(value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.FP64().getText().lower()) + + def visitBooleanArg(self, ctx: TestFileParser.BooleanArgContext): + return CaseLiteral(value=ctx.BOOLEAN_LITERAL().getText(), type="bool") + + def visitStringArg(self, ctx: TestFileParser.StringArgContext): + return CaseLiteral(value=ctx.STRING_LITERAL().getText(), type="str") + + def visitDecimalArg(self, ctx: TestFileParser.DecimalArgContext): + return CaseLiteral(value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.decimalType().getText().lower()) + + def visitDateArg(self, ctx: TestFileParser.DateArgContext): + return CaseLiteral(value=ctx.DATE_LITERAL().getText().strip("'"), type="date") + + def visitTimeArg(self, ctx: TestFileParser.TimeArgContext): + return CaseLiteral(value=ctx.TIME_LITERAL().getText().strip("'"), type="time") + + def visitTimestampArg(self, ctx: TestFileParser.TimestampArgContext): + return CaseLiteral(value=ctx.TIMESTAMP_LITERAL().getText().strip("'"), type="ts") + + def visitTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): + return CaseLiteral(value=ctx.TIMESTAMP_TZ_LITERAL().getText().strip("'"), type="tstz") + + def visitIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): + return CaseLiteral(value=ctx.INTERVAL_DAY_LITERAL().getText().strip("'"), type="iday") + + def visitIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): + return CaseLiteral(value=ctx.INTERVAL_YEAR_LITERAL().getText().strip("'"), type="iyear") + + def visitResult(self, ctx: TestFileParser.ResultContext): + if ctx.argument() is not None: + return self.visitArgument(ctx.argument()) + return self.visitSubstraitError(ctx.substraitError()) + + def visitSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): + if ctx.ERROR_RESULT() is not None: + return "error" + if ctx.UNDEFINED_RESULT() is not None: + return "undefined" + return "unknown_error" From 1aa164b089dcc1c57a88f9bd82ab10d8186c871f Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Mon, 2 Sep 2024 16:28:20 +0530 Subject: [PATCH 04/19] Changes to load extension files --- tests/coverage/extensions.py | 244 +++++++++++++++++++++++++++++++++++ tests/test_extensions.py | 10 ++ 2 files changed, 254 insertions(+) create mode 100644 tests/coverage/extensions.py create mode 100644 tests/test_extensions.py diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py new file mode 100644 index 000000000..d08a6cc53 --- /dev/null +++ b/tests/coverage/extensions.py @@ -0,0 +1,244 @@ +import os +import yaml +from ruamel.yaml import YAML + + +def error(msg): + print(f"ERROR: {msg}") + + +def debug(msg): + print(f"DEBUG: {msg}") + + +type_to_short_type = { + 'required enumeration': 'req', + 'i8': 'i8', + 'i16': 'i16', + 'i32': 'i32', + 'i64': 'i64', + 'fp32': 'fp32', + 'fp64': 'fp64', + 'string': 'str', + 'binary': 'vbin', + 'boolean': 'bool', + 'timestamp': 'ts', + 'timestamp_tz': 'tstz', + 'date': 'date', + 'time': 'time', + 'interval_year': 'iyear', + 'interval_day': 'iday', + 'uuid': 'uuid', + 'fixedchar': 'fchar', + 'varchar': 'vchar', + 'fixedbinary': 'fbin', + 'decimal': 'dec', + 'precision_timestamp

': 'pts', + 'precision_timestamp_tz

': 'ptstz', + 'struct': 'struct', + 'list': 'list', + 'map': 'map', + 'map': 'map', + 'any': 'any', + 'any1': 'any1', + 'any2': 'any2', + 'any3': 'any3', + 'user defined type': 'u!name', + + # added to handle parametrized types + 'fixedchar': 'fchar', + 'varchar': 'vchar', + 'fixedbinary': 'fbin', + 'decimal': 'dec', + 'precision_timestamp': 'pts', + 'precision_timestamp_tz': 'ptstz', + 'struct': 'struct', + 'list': 'list', + + # added to handle geometry type + 'geometry': 'geometry', +} + +short_type_to_type = {st: lt for lt, st in type_to_short_type.items()} + + +class Extension: + @staticmethod + def get_base_uri(): + return 'https://github.com/substrait-io/substrait/blob/main/extensions/' + + @staticmethod + def get_short_type(long_type): + long_type = long_type.lower() + if long_type.endswith('?'): + long_type = long_type[:-1] + short_type = type_to_short_type.get(long_type, None) + if short_type is None: + # remove the type parameters and try again + if '<' in long_type: + long_type = long_type[:long_type.find('<')] + if long_type.endswith('?'): + long_type = long_type[:-1] + short_type = type_to_short_type.get(long_type, None) + if short_type is None: + if '!' not in long_type: + error(f"Type not found in the mapping: {long_type}") + return long_type + return short_type + + @staticmethod + def get_long_type(short_type): + if short_type.endswith('?'): + short_type = short_type[:-1] + long_type = short_type_to_type.get(short_type, None) + if long_type is None: + error(f"Type not found in the mapping: {short_type}") + return short_type + return long_type + + @staticmethod + def get_supported_kernels_from_impls(func): + overloads = [] + for impl in func['impls']: + args = [] + if 'args' in impl: + for arg in impl['args']: + if 'value' in arg: + arg_type = arg['value'] + if arg_type.endswith('?'): + arg_type = arg_type[:-1] + args.append(Extension.get_short_type(arg_type)) + else: + debug(f"arg is not a value type for function: {func['name']} arg must be enum options {arg['options']}") + args.append('str') + overloads.append(FunctionOverload(args, Extension.get_short_type(impl['return']), 'variadic' in impl)) + return overloads + + @staticmethod + def add_functions_to_map(func_list, function_map, suffix, extension): + dup_idx = 0 + for func in func_list: + name = func['name'] + uri = f"{suffix}.{name}" + if name in function_map: + debug(f"Duplicate function name: {name} renaming to {name}_{suffix} extension: {extension}") + dup_idx += 1 + name = f"{name}_dup{dup_idx}_{suffix}" + assert name not in function_map, f"Duplicate function name: {name} renaming to {name}_{suffix} extension: {extension}" + func['overloads'] = Extension.get_supported_kernels_from_impls(func) + func['uri'] = uri + func.pop('description', None) + func.pop('impls', None) + function_map[name] = func + + @staticmethod + def read_substrait_extensions(dir_path: str): + # read files from extensions directory + extensions = [] + for root, dirs, files in os.walk(dir_path): + for file in files: + if file.endswith('.yaml') and file.startswith('functions_'): + extensions.append(os.path.join(root, file)) + + extensions.sort() + + scalar_functions = {} + aggregate_functions = {} + window_functions = {} + dependencies = {} + # convert yaml file to a python dictionary + for extension in extensions: + suffix = extension[:-5] # strip .yaml at the end of the extension + suffix = suffix[suffix.rfind('/') + 1:] # strip the path and get the name of the extension + suffix = suffix[suffix.find('_') + 1:] # get the suffix after the last _ + + dependencies[suffix] = Extension.get_base_uri() + extension + with open(extension, 'r') as fh: + data = yaml.load(fh, Loader=yaml.FullLoader) + if 'scalar_functions' in data: + Extension.add_functions_to_map(data['scalar_functions'], scalar_functions, suffix, extension) + if 'aggregate_functions' in data: + Extension.add_functions_to_map(data['aggregate_functions'], aggregate_functions, suffix, extension) + if 'window_functions' in data: + Extension.add_functions_to_map(data['window_functions'], scalar_functions, suffix, extension) + + return FunctionRegistry(scalar_functions, aggregate_functions, window_functions, dependencies) + + +class FunctionType: + SCALAR = 1 + AGGREGATE = 2 + WINDOW = 3 + + +class FunctionVariant: + def __init__(self, name, uri, description, args, return_type, variadic, func_type): + self.name = name + self.uri = uri + self.description = description + self.args = args + self.return_type = return_type + self.variadic = variadic + self.func_type = func_type + self.test_count = 0 + + def __str__(self): + return f"Function(name={self.name}, uri={self.uri}, description={self.description}, overloads={self.overload}, args={self.args}, result={self.result})" + + def increment_test_count(self, count): + self.test_count += count + + +class FunctionOverload: + def __init__(self, args, return_type, variadic): + self.args = args + self.return_type = return_type + self.variadic = variadic + + def __str__(self): + return f"FunctionOverload(args={self.args}, result={self.return_type}, variadic={self.variadic})" + +# define function type enum + + +class FunctionRegistry: + registry = dict() + dependencies = dict() + scalar_functions = dict() + aggregate_functions = dict() + window_functions = dict() + + def __init__(self, scalar_functions, aggregate_functions, window_functions, dependencies): + self.dependencies = dependencies + self.scalar_functions = scalar_functions + self.aggregate_functions = aggregate_functions + self.window_functions = window_functions + self.add_functions(scalar_functions, FunctionType.SCALAR) + self.add_functions(aggregate_functions, FunctionType.AGGREGATE) + self.add_functions(window_functions, FunctionType.WINDOW) + + def add_functions(self, functions, func_type): + for func in functions.values(): + f_name = func["name"] + fun_arr = self.registry.get(f_name, []) + for overload in func["overloads"]: + function = FunctionVariant(func["name"], func["uri"], "", overload.args, overload.return_type, overload.variadic, func_type) + fun_arr.append(function) + self.registry[f_name] = fun_arr + + def get_function(self, name, args) -> [FunctionVariant]: + functions = self.registry.get(name, None) + if functions is None: + return None + for function in functions: + if function.args == args: + return function + + def get_test_coverage(self): + + test_count = 0 + for functions in self.registry.values(): + for function in functions: + test_count += function.test_count + return test_count + diff --git a/tests/test_extensions.py b/tests/test_extensions.py new file mode 100644 index 000000000..3f94b85b9 --- /dev/null +++ b/tests/test_extensions.py @@ -0,0 +1,10 @@ +def test_read_substrait_extensions(): + from tests.coverage.extensions import Extension + registry = Extension.read_substrait_extensions('../extensions') + assert len(registry.registry) >= 143 + num_overloads = sum([len(f) for f in registry.registry.values()]) + assert num_overloads >= 425 + assert len(registry.dependencies) >= 13 + assert len(registry.scalar_functions) >= 162 + assert len(registry.aggregate_functions) >= 29 + assert len(registry.window_functions) >= 0 From 547b76b7426a0a3989dc183caadd272c3f48561f Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Mon, 2 Sep 2024 16:28:59 +0530 Subject: [PATCH 05/19] Initial changes for coverage tool --- tests/__init__.py | 0 tests/coverage/case_file_parser.py | 49 ++++++++++++++ tests/coverage/coverage.py | 103 +++++++++++++++++++---------- tests/coverage/nodes.py | 29 +++++++- tests/coverage/test_coverage.py | 12 ++-- tests/coverage/visitor.py | 16 +++-- 6 files changed, 161 insertions(+), 48 deletions(-) create mode 100644 tests/__init__.py create mode 100644 tests/coverage/case_file_parser.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/coverage/case_file_parser.py b/tests/coverage/case_file_parser.py new file mode 100644 index 000000000..68bb82060 --- /dev/null +++ b/tests/coverage/case_file_parser.py @@ -0,0 +1,49 @@ +import os + +from antlr4 import CommonTokenStream, FileStream + +from tests.coverage.antlr_generated.TestFileLexer import TestFileLexer +from tests.coverage.antlr_generated.TestFileParser import TestFileParser +from tests.coverage.visitor import TestCaseVisitor + + +def parse_stream(input_stream, file_path): + # Create a lexer and parser + lexer = TestFileLexer(input_stream) + token_stream = CommonTokenStream(lexer) + parser = TestFileParser(token_stream) + + tree = parser.doc() # This is the entry point of testfile parser + if parser.getNumberOfSyntaxErrors() > 0: + print(tree.toStringTree(recog=parser)) + print(f"{parser.getNumberOfSyntaxErrors()} Syntax errors found, exiting") + return + + # uncomment below line to see the parse tree for debugging + # print(tree.toStringTree(recog=parser)) + + visitor = TestCaseVisitor(file_path) + test_file = visitor.visit(tree) + return test_file + + +def parse_one_file(file_path): + return parse_stream(FileStream(file_path), file_path) + + +def parse_testcase_directory_recursively(dir_path): + # for each file in directory call parse_one_file + test_files = [] + for child in os.listdir(dir_path): + child_path = os.path.join(dir_path, child) + if os.path.isfile(child_path) and child.endswith(".test"): + test_file = parse_one_file(child_path) + test_files.append(test_file) + elif os.path.isdir(child_path): + test_files_in_a_dir = parse_testcase_directory_recursively(child_path) + test_files.extend(test_files_in_a_dir) + return test_files + + +def load_all_testcases(dir_path) -> list: + return parse_testcase_directory_recursively(dir_path) diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index 053b3ad02..6d0b962f3 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -1,48 +1,83 @@ # SPDX-License-Identifier: Apache-2.0 -import os -from antlr4 import FileStream, InputStream, CommonTokenStream -from tests.coverage.antlr_generated.TestFileLexer import TestFileLexer -from tests.coverage.antlr_generated.TestFileParser import TestFileParser -from tests.coverage.visitor import TestCaseVisitor +from tests.coverage.case_file_parser import load_all_testcases +from tests.coverage.extensions import Extension, error -def parse_one_file(file_path): - return parse_stream(FileStream(file_path)) +class FunctionTestCoverage: + function_name: str + test_count: int + function_variant_coverage: {str: int} + def __init__(self, function_name): + self.function_name = function_name + self.test_count = 0 + self.function_variant_coverage = dict() -def parse_stream(input_stream): - # Create a lexer and parser - lexer = TestFileLexer(input_stream) - token_stream = CommonTokenStream(lexer) - parser = TestFileParser(token_stream) + def update_coverage(self, function_variant): + if function_variant not in self.function_variant_coverage: + self.function_variant_coverage[function_variant] = 0 + self.function_variant_coverage[function_variant] += 1 + self.test_count += 1 - tree = parser.doc() # This is the entry point of testfile parser - if parser.getNumberOfSyntaxErrors() > 0: - print(tree.toStringTree(recog=parser)) - print(f"{parser.getNumberOfSyntaxErrors()} Syntax errors found, exiting") - return - # Optionally, print the parse tree in LISP format - print(tree.toStringTree(recog=parser)) +class FileTestCoverage: + file_name: str + test_count: int + function_coverage: {str: FunctionTestCoverage} - # TODO use custom visitor to build test cases and compute coverage - visitor = TestCaseVisitor() - test_file = visitor.visit(tree) - return test_file + def __init__(self, file_name): + self.file_name = file_name + self.test_count = 0 + self.function_coverage = dict() + def update_coverage(self, func_name, args): + key = f"{func_name}({", ".join(args)})" + if func_name not in self.function_coverage: + self.function_coverage[func_name] = FunctionTestCoverage(func_name) + self.function_coverage[func_name].update_coverage(key) + self.test_count += 1 -def parse_directory_recursively(dirPath): - # for each file in directory call parse_one_file - test_files = [] - for file in os.listdir(dirPath): - if os.path.isfile(file) and file.endswith(".test"): - test_file = parse_one_file(file) - test_files.append(test_file) - elif os.path.isdir(file): - parse_directory_recursively(file) + +class TestCoverage: + file_coverage: {str: FileTestCoverage} + test_count: int + + def __init__(self): + self.file_coverage = dict() + self.test_count = 0 + + def update_coverage(self, ext_uri, function, args): + if ext_uri not in self.file_coverage: + self.file_coverage[ext_uri] = FileTestCoverage(ext_uri) + self.file_coverage[ext_uri].update_coverage(function, args) + self.test_count += 1 + + def dump_coverage(self): + for file_coverage in self.file_coverage.values(): + print(f"File: {file_coverage.file_name}") + for function_coverage in file_coverage.function_coverage.values(): + print(f"\tFunction: {function_coverage.function_name}: {function_coverage.test_count}") + for sig, test_count in function_coverage.function_variant_coverage.items(): + print(f"\t\t{sig}: {test_count}") + + +def update_test_count(test_case_files, function_registry, coverage): + for test_file in test_case_files: + for test_case in test_file.testcases: + function_variant = function_registry.get_function(test_case.func_name, test_case.get_arg_types()) + if function_variant is not None: + if function_variant.return_type != test_case.get_return_type() and not test_case.is_return_type_error(): + error(f"Return type mismatch in function {test_case.func_name}: {function_variant.return_type} != {test_case.get_return_type()}") + coverage.update_coverage(function_variant.uri, test_case.func_name, test_case.get_arg_types()) + else: + print(f"Function not found: {test_case.func_name}({test_case.args})") if __name__ == "__main__": - # TODO move these tests to test folder - parse_directory_recursively("../cases") + test_files = load_all_testcases('../cases') + extensions = Extension.read_substrait_extensions("../../extensions") + coverage = TestCoverage() + update_test_count(test_files, extensions, coverage) + coverage.dump_coverage() + diff --git a/tests/coverage/nodes.py b/tests/coverage/nodes.py index 66919c9a4..5dc7ec09e 100644 --- a/tests/coverage/nodes.py +++ b/tests/coverage/nodes.py @@ -8,15 +8,27 @@ class CaseGroup: description: str +@dataclass +class SubstraitError: + error: str + @dataclass class CaseLiteral: value: str | int | float | list type: str + def get_base_type(self): + type = self.type + if '<' in type: + type = type[:type.find('<')] + if type.endswith('?'): + return type[:-1] + return type + @dataclass class TestCase: - function: str + func_name: str base_uri: str group: CaseGroup options: dict @@ -24,9 +36,24 @@ class TestCase: result: CaseLiteral | str comment: str + def get_return_type(self): + if isinstance(self.result, CaseLiteral): + return self.result.type + return self.result + + def is_return_type_error(self): + return isinstance(self.result, SubstraitError) + + def get_arg_types(self): + return [arg.get_base_type() for arg in self.args] + + def get_signature(self): + return f"{self.func_name}({', '.join([arg.type for arg in self.args])})" + @dataclass class TestFile: + path: str version: str include: str testcases: List[TestCase] diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py index 1410766de..1f1eec1f7 100644 --- a/tests/coverage/test_coverage.py +++ b/tests/coverage/test_coverage.py @@ -1,5 +1,5 @@ from antlr4 import InputStream -from tests.coverage.coverage import parse_stream, parse_one_file +from tests.coverage.case_file_parser import parse_stream, parse_one_file from tests.coverage.nodes import CaseLiteral @@ -33,7 +33,7 @@ def test_parse_date_time_example(): """ ) assert len(test_file.testcases) == 1 - assert test_file.testcases[0].function == "lt" + assert test_file.testcases[0].func_name == "lt" assert test_file.testcases[0].base_uri == "/extensions/functions_datetime.yaml" assert test_file.testcases[0].group.name == "timestamps" assert test_file.testcases[0].group.description == "examples using the timestamp type" @@ -53,7 +53,7 @@ def test_parse_decimal_example(): """ ) assert len(test_file.testcases) == 2 - assert test_file.testcases[0].function == "power" + assert test_file.testcases[0].func_name == "power" assert test_file.testcases[0].base_uri == "extensions/functions_arithmetic_decimal.yaml" assert test_file.testcases[0].group.name == "basic" assert test_file.testcases[0].group.description == "Basic examples without any special cases" @@ -65,16 +65,16 @@ def test_parse_decimal_example(): def test_parse_file(): test_file = parse_one_file("../cases/arithmetic/add.test") assert len(test_file.testcases) == 15 - assert test_file.testcases[0].function == "add" + assert test_file.testcases[0].func_name == "add" assert test_file.testcases[0].base_uri == "/extensions/functions_arithmetic.yaml" assert test_file.include == "/extensions/functions_arithmetic.yaml" test_file = parse_one_file("../cases/datetime/lt_datetime.test") assert len(test_file.testcases) == 13 - assert test_file.testcases[0].function == "lt" + assert test_file.testcases[0].func_name == "lt" assert test_file.testcases[0].base_uri == "/extensions/functions_datetime.yaml" test_file = parse_one_file("../cases/arithmetic_decimal/power.test") assert len(test_file.testcases) == 9 - assert test_file.testcases[0].function == "power" + assert test_file.testcases[0].func_name == "power" assert test_file.testcases[0].base_uri == "extensions/functions_arithmetic_decimal.yaml" diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index 8afc8827c..f808cefbf 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -1,12 +1,14 @@ # SPDX-License-Identifier: Apache-2.0 from tests.coverage.antlr_generated.TestFileParser import TestFileParser from tests.coverage.antlr_generated.TestFileParserVisitor import TestFileParserVisitor -from tests.coverage.nodes import CaseGroup, TestFile, TestCase, CaseLiteral +from tests.coverage.nodes import CaseGroup, TestFile, TestCase, CaseLiteral, SubstraitError class TestCaseVisitor(TestFileParserVisitor): + def __init__(self, file_path): + self.file_path = file_path + def visitDoc(self, ctx: TestFileParser.DocContext): - # TODO Implement this method version, include = self.visitHeader(ctx.header()) testcases = [] for group in ctx.testGroup(): @@ -15,7 +17,7 @@ def visitDoc(self, ctx: TestFileParser.DocContext): test_case.base_uri = include testcases.extend(group_tests) - return TestFile(version, include, testcases) + return TestFile(self.file_path, version, include, testcases) def visitHeader(self, ctx: TestFileParser.HeaderContext): version = self.visitVersion(ctx.version()) @@ -53,7 +55,7 @@ def visitTestCase(self, ctx: TestFileParser.TestCaseContext): options = dict() if ctx.func_options() is not None: options = self.visitFunc_options(ctx.func_options()) - return TestCase(function=ctx.IDENTIFIER().getText(), + return TestCase(func_name=ctx.IDENTIFIER().getText(), base_uri="", group=None, options=options, @@ -179,7 +181,7 @@ def visitResult(self, ctx: TestFileParser.ResultContext): def visitSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): if ctx.ERROR_RESULT() is not None: - return "error" + return SubstraitError("error") if ctx.UNDEFINED_RESULT() is not None: - return "undefined" - return "unknown_error" + return SubstraitError("undefined") + return SubstraitError("unknown_error") From 58249db59d14966e91f7ada6f6090ff1d8100fe9 Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Mon, 2 Sep 2024 20:47:47 +0530 Subject: [PATCH 06/19] coverage tool fixes --- tests/coverage/coverage.py | 62 ++++++++++++++++++++---------------- tests/coverage/extensions.py | 34 ++++++++++++-------- tests/test_extensions.py | 4 +-- 3 files changed, 57 insertions(+), 43 deletions(-) diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index 6d0b962f3..b6056961f 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -1,83 +1,91 @@ # SPDX-License-Identifier: Apache-2.0 +from collections import defaultdict from tests.coverage.case_file_parser import load_all_testcases -from tests.coverage.extensions import Extension, error +from tests.coverage.extensions import Extension, error, FunctionRegistry class FunctionTestCoverage: function_name: str test_count: int - function_variant_coverage: {str: int} + function_variant_coverage: defaultdict[str, int] def __init__(self, function_name): self.function_name = function_name self.test_count = 0 - self.function_variant_coverage = dict() + self.function_variant_coverage = defaultdict(int) - def update_coverage(self, function_variant): - if function_variant not in self.function_variant_coverage: - self.function_variant_coverage[function_variant] = 0 - self.function_variant_coverage[function_variant] += 1 - self.test_count += 1 + def update_coverage(self, function_variant, count): + self.function_variant_coverage[function_variant] += count + self.test_count += count class FileTestCoverage: file_name: str test_count: int - function_coverage: {str: FunctionTestCoverage} + function_coverage: dict[str, FunctionTestCoverage] def __init__(self, file_name): self.file_name = file_name self.test_count = 0 self.function_coverage = dict() - def update_coverage(self, func_name, args): + def update_coverage(self, func_name, args, count): key = f"{func_name}({", ".join(args)})" if func_name not in self.function_coverage: self.function_coverage[func_name] = FunctionTestCoverage(func_name) - self.function_coverage[func_name].update_coverage(key) - self.test_count += 1 + self.function_coverage[func_name].update_coverage(key, count) + self.test_count += count class TestCoverage: - file_coverage: {str: FileTestCoverage} + file_coverage: dict[str, FileTestCoverage] test_count: int - def __init__(self): + def __init__(self, ext_uris): self.file_coverage = dict() self.test_count = 0 + for ext_uri in ext_uris: + self.file_coverage[ext_uri] = FileTestCoverage(ext_uri) - def update_coverage(self, ext_uri, function, args): + def update_coverage(self, ext_uri, function, args, count): if ext_uri not in self.file_coverage: self.file_coverage[ext_uri] = FileTestCoverage(ext_uri) - self.file_coverage[ext_uri].update_coverage(function, args) - self.test_count += 1 + self.file_coverage[ext_uri].update_coverage(function, args, count) + self.test_count += count def dump_coverage(self): + covered_variants = 0 + total_variants = 0 for file_coverage in self.file_coverage.values(): - print(f"File: {file_coverage.file_name}") for function_coverage in file_coverage.function_coverage.values(): - print(f"\tFunction: {function_coverage.function_name}: {function_coverage.test_count}") for sig, test_count in function_coverage.function_variant_coverage.items(): - print(f"\t\t{sig}: {test_count}") + total_variants += 1 + if test_count > 0: + covered_variants += 1 + print(f"{file_coverage.file_name} \t\t{sig}: {test_count}") + print(f"Total test count: {self.test_count}, {covered_variants}/{total_variants} function variants are covered") -def update_test_count(test_case_files, function_registry, coverage): +def update_test_count(test_case_files: list, function_registry: FunctionRegistry): for test_file in test_case_files: for test_case in test_file.testcases: function_variant = function_registry.get_function(test_case.func_name, test_case.get_arg_types()) - if function_variant is not None: + if function_variant: if function_variant.return_type != test_case.get_return_type() and not test_case.is_return_type_error(): error(f"Return type mismatch in function {test_case.func_name}: {function_variant.return_type} != {test_case.get_return_type()}") - coverage.update_coverage(function_variant.uri, test_case.func_name, test_case.get_arg_types()) + continue + function_variant.increment_test_count() else: - print(f"Function not found: {test_case.func_name}({test_case.args})") + error(f"Function not found: {test_case.func_name}({test_case.args})") + if __name__ == "__main__": test_files = load_all_testcases('../cases') - extensions = Extension.read_substrait_extensions("../../extensions") - coverage = TestCoverage() - update_test_count(test_files, extensions, coverage) + function_registry = Extension.read_substrait_extensions("../../extensions") + coverage = TestCoverage(function_registry.get_extension_list()) + update_test_count(test_files, function_registry) + function_registry.fill_coverage(coverage) coverage.dump_coverage() diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index d08a6cc53..675090e78 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -2,13 +2,16 @@ import yaml from ruamel.yaml import YAML +enable_debug = False + def error(msg): print(f"ERROR: {msg}") def debug(msg): - print(f"DEBUG: {msg}") + if enable_debug: + print(f"DEBUG: {msg}") type_to_short_type = { @@ -69,17 +72,18 @@ def get_base_uri(): @staticmethod def get_short_type(long_type): - long_type = long_type.lower() - if long_type.endswith('?'): - long_type = long_type[:-1] + long_type = long_type.lower().rstrip('?') short_type = type_to_short_type.get(long_type, None) + if short_type is None: # remove the type parameters and try again if '<' in long_type: - long_type = long_type[:long_type.find('<')] - if long_type.endswith('?'): - long_type = long_type[:-1] + long_type = long_type[:long_type.find('<')].rstrip('?') short_type = type_to_short_type.get(long_type, None) + if short_type is None: + if '\n' in long_type: + long_type = long_type.split('\n')[-1] + short_type = type_to_short_type.get(long_type, None) if short_type is None: if '!' not in long_type: error(f"Type not found in the mapping: {long_type}") @@ -119,7 +123,7 @@ def add_functions_to_map(func_list, function_map, suffix, extension): dup_idx = 0 for func in func_list: name = func['name'] - uri = f"{suffix}.{name}" + uri = extension[5:] # strip the ../.. if name in function_map: debug(f"Duplicate function name: {name} renaming to {name}_{suffix} extension: {extension}") dup_idx += 1 @@ -185,7 +189,7 @@ def __init__(self, name, uri, description, args, return_type, variadic, func_typ def __str__(self): return f"Function(name={self.name}, uri={self.uri}, description={self.description}, overloads={self.overload}, args={self.args}, result={self.result})" - def increment_test_count(self, count): + def increment_test_count(self, count=1): self.test_count += count @@ -207,6 +211,7 @@ class FunctionRegistry: scalar_functions = dict() aggregate_functions = dict() window_functions = dict() + extensions = set() def __init__(self, scalar_functions, aggregate_functions, window_functions, dependencies): self.dependencies = dependencies @@ -219,6 +224,7 @@ def __init__(self, scalar_functions, aggregate_functions, window_functions, depe def add_functions(self, functions, func_type): for func in functions.values(): + self.extensions.add(func['uri']) f_name = func["name"] fun_arr = self.registry.get(f_name, []) for overload in func["overloads"]: @@ -234,11 +240,11 @@ def get_function(self, name, args) -> [FunctionVariant]: if function.args == args: return function - def get_test_coverage(self): + def get_extension_list(self): + return list(self.extensions) - test_count = 0 - for functions in self.registry.values(): + def fill_coverage(self, coverage): + for func_name, functions in self.registry.items(): for function in functions: - test_count += function.test_count - return test_count + coverage.update_coverage(function.uri, func_name, function.args, function.test_count) diff --git a/tests/test_extensions.py b/tests/test_extensions.py index 3f94b85b9..d63778ba7 100644 --- a/tests/test_extensions.py +++ b/tests/test_extensions.py @@ -1,8 +1,8 @@ def test_read_substrait_extensions(): from tests.coverage.extensions import Extension registry = Extension.read_substrait_extensions('../extensions') - assert len(registry.registry) >= 143 - num_overloads = sum([len(f) for f in registry.registry.values()]) + assert len(registry.function_registry) >= 143 + num_overloads = sum([len(f) for f in registry.function_registry.values()]) assert num_overloads >= 425 assert len(registry.dependencies) >= 13 assert len(registry.scalar_functions) >= 162 From adcce01cee126b8429af0aa28de6fb692dfcf97b Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Mon, 2 Sep 2024 21:22:31 +0530 Subject: [PATCH 07/19] Add auto-generated parser files --- grammar/Makefile | 2 +- .../antlr_parser/SubstraitLexer.interp | 228 + tests/coverage/antlr_parser/SubstraitLexer.py | 344 ++ .../antlr_parser/SubstraitLexer.tokens | 74 + .../antlr_parser/TestFileLexer.interp | 330 ++ tests/coverage/antlr_parser/TestFileLexer.py | 593 +++ .../antlr_parser/TestFileLexer.tokens | 127 + .../antlr_parser/TestFileParser.interp | 244 + tests/coverage/antlr_parser/TestFileParser.py | 4126 +++++++++++++++++ .../antlr_parser/TestFileParser.tokens | 127 + .../antlr_parser/TestFileParserListener.py | 561 +++ .../antlr_parser/TestFileParserVisitor.py | 318 ++ tests/coverage/case_file_parser.py | 4 +- tests/coverage/visitor.py | 4 +- 14 files changed, 7077 insertions(+), 5 deletions(-) create mode 100644 tests/coverage/antlr_parser/SubstraitLexer.interp create mode 100644 tests/coverage/antlr_parser/SubstraitLexer.py create mode 100644 tests/coverage/antlr_parser/SubstraitLexer.tokens create mode 100644 tests/coverage/antlr_parser/TestFileLexer.interp create mode 100644 tests/coverage/antlr_parser/TestFileLexer.py create mode 100644 tests/coverage/antlr_parser/TestFileLexer.tokens create mode 100644 tests/coverage/antlr_parser/TestFileParser.interp create mode 100644 tests/coverage/antlr_parser/TestFileParser.py create mode 100644 tests/coverage/antlr_parser/TestFileParser.tokens create mode 100644 tests/coverage/antlr_parser/TestFileParserListener.py create mode 100644 tests/coverage/antlr_parser/TestFileParserVisitor.py diff --git a/grammar/Makefile b/grammar/Makefile index ca94c7bee..b5dedc915 100644 --- a/grammar/Makefile +++ b/grammar/Makefile @@ -1,6 +1,6 @@ ANTLR_JAR=antlr-4.13.2-complete.jar GRAMMARS=SubstraitLexer.g4 TestFileLexer.g4 TestFileParser.g4 -OUTPUT_DIR=../tests/coverage/antlr_generated +OUTPUT_DIR=../tests/coverage/antlr_parser generate: java -jar $(ANTLR_JAR) -visitor -Dlanguage=Python3 -o $(OUTPUT_DIR) $(GRAMMARS) diff --git a/tests/coverage/antlr_parser/SubstraitLexer.interp b/tests/coverage/antlr_parser/SubstraitLexer.interp new file mode 100644 index 000000000..b34496d1a --- /dev/null +++ b/tests/coverage/antlr_parser/SubstraitLexer.interp @@ -0,0 +1,228 @@ +token literal names: +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'::' +null +'<' +'>' +'(' +')' +'[' +']' +',' +'=' +':' +'?' +'#' +'.' + +token symbolic names: +null +LineComment +BlockComment +Whitespace +If +Then +Else +Boolean +I8 +I16 +I32 +I64 +FP32 +FP64 +String +Binary +Timestamp +TimestampTZ +Date +Time +IntervalYear +IntervalDay +UUID +Decimal +PrecisionTimestamp +PrecisionTimestampTZ +FixedChar +VarChar +FixedBinary +Struct +NStruct +List +Map +ANY +UserDefined +Bool +Str +VBin +Ts +TsTZ +IYear +IDay +Dec +PTs +PTsTZ +FChar +VChar +FBin +DOUBLE_COLON +IDENTIFIER +O_ANGLE_BRACKET +C_ANGLE_BRACKET +OPAREN +CPAREN +OBRACKET +CBRACKET +COMMA +EQ +COLON +QMARK +HASH +DOT + +rule names: +LineComment +BlockComment +Whitespace +A +B +C +D +E +F +G +H +I +J +K +L +M +N +O +P +Q +R +S +T +U +V +W +X +Y +Z +DIGIT +INTEGER +If +Then +Else +Boolean +I8 +I16 +I32 +I64 +FP32 +FP64 +String +Binary +Timestamp +TimestampTZ +Date +Time +IntervalYear +IntervalDay +UUID +Decimal +PrecisionTimestamp +PrecisionTimestampTZ +FixedChar +VarChar +FixedBinary +Struct +NStruct +List +Map +ANY +UserDefined +Bool +Str +VBin +Ts +TsTZ +IYear +IDay +Dec +PTs +PTsTZ +FChar +VChar +FBin +DOUBLE_COLON +IDENTIFIER +O_ANGLE_BRACKET +C_ANGLE_BRACKET +OPAREN +CPAREN +OBRACKET +CBRACKET +COMMA +EQ +COLON +QMARK +HASH +DOT + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 61, 619, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 184, 8, 0, 10, 0, 12, 0, 187, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 196, 8, 1, 11, 1, 12, 1, 197, 1, 1, 3, 1, 201, 8, 1, 1, 1, 5, 1, 204, 8, 1, 10, 1, 12, 1, 207, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 2, 215, 8, 2, 11, 2, 12, 2, 216, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 5, 30, 278, 8, 30, 10, 30, 12, 30, 281, 9, 30, 3, 30, 283, 8, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 5, 76, 591, 8, 76, 10, 76, 12, 76, 594, 9, 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, 1, 88, 0, 0, 89, 1, 1, 3, 2, 5, 3, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0, 17, 0, 19, 0, 21, 0, 23, 0, 25, 0, 27, 0, 29, 0, 31, 0, 33, 0, 35, 0, 37, 0, 39, 0, 41, 0, 43, 0, 45, 0, 47, 0, 49, 0, 51, 0, 53, 0, 55, 0, 57, 0, 59, 0, 61, 0, 63, 4, 65, 5, 67, 6, 69, 7, 71, 8, 73, 9, 75, 10, 77, 11, 79, 12, 81, 13, 83, 14, 85, 15, 87, 16, 89, 17, 91, 18, 93, 19, 95, 20, 97, 21, 99, 22, 101, 23, 103, 24, 105, 25, 107, 26, 109, 27, 111, 28, 113, 29, 115, 30, 117, 31, 119, 32, 121, 33, 123, 34, 125, 35, 127, 36, 129, 37, 131, 38, 133, 39, 135, 40, 137, 41, 139, 42, 141, 43, 143, 44, 145, 45, 147, 46, 149, 47, 151, 48, 153, 49, 155, 50, 157, 51, 159, 52, 161, 53, 163, 54, 165, 55, 167, 56, 169, 57, 171, 58, 173, 59, 175, 60, 177, 61, 1, 0, 34, 2, 0, 10, 10, 13, 13, 1, 0, 42, 42, 2, 0, 42, 42, 47, 47, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 69, 69, 101, 101, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 1, 0, 48, 57, 1, 0, 49, 57, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 598, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 1, 179, 1, 0, 0, 0, 3, 190, 1, 0, 0, 0, 5, 214, 1, 0, 0, 0, 7, 220, 1, 0, 0, 0, 9, 222, 1, 0, 0, 0, 11, 224, 1, 0, 0, 0, 13, 226, 1, 0, 0, 0, 15, 228, 1, 0, 0, 0, 17, 230, 1, 0, 0, 0, 19, 232, 1, 0, 0, 0, 21, 234, 1, 0, 0, 0, 23, 236, 1, 0, 0, 0, 25, 238, 1, 0, 0, 0, 27, 240, 1, 0, 0, 0, 29, 242, 1, 0, 0, 0, 31, 244, 1, 0, 0, 0, 33, 246, 1, 0, 0, 0, 35, 248, 1, 0, 0, 0, 37, 250, 1, 0, 0, 0, 39, 252, 1, 0, 0, 0, 41, 254, 1, 0, 0, 0, 43, 256, 1, 0, 0, 0, 45, 258, 1, 0, 0, 0, 47, 260, 1, 0, 0, 0, 49, 262, 1, 0, 0, 0, 51, 264, 1, 0, 0, 0, 53, 266, 1, 0, 0, 0, 55, 268, 1, 0, 0, 0, 57, 270, 1, 0, 0, 0, 59, 272, 1, 0, 0, 0, 61, 282, 1, 0, 0, 0, 63, 284, 1, 0, 0, 0, 65, 287, 1, 0, 0, 0, 67, 292, 1, 0, 0, 0, 69, 297, 1, 0, 0, 0, 71, 305, 1, 0, 0, 0, 73, 308, 1, 0, 0, 0, 75, 312, 1, 0, 0, 0, 77, 316, 1, 0, 0, 0, 79, 320, 1, 0, 0, 0, 81, 325, 1, 0, 0, 0, 83, 330, 1, 0, 0, 0, 85, 337, 1, 0, 0, 0, 87, 344, 1, 0, 0, 0, 89, 354, 1, 0, 0, 0, 91, 367, 1, 0, 0, 0, 93, 372, 1, 0, 0, 0, 95, 377, 1, 0, 0, 0, 97, 391, 1, 0, 0, 0, 99, 404, 1, 0, 0, 0, 101, 409, 1, 0, 0, 0, 103, 417, 1, 0, 0, 0, 105, 437, 1, 0, 0, 0, 107, 460, 1, 0, 0, 0, 109, 470, 1, 0, 0, 0, 111, 478, 1, 0, 0, 0, 113, 490, 1, 0, 0, 0, 115, 497, 1, 0, 0, 0, 117, 505, 1, 0, 0, 0, 119, 510, 1, 0, 0, 0, 121, 514, 1, 0, 0, 0, 123, 518, 1, 0, 0, 0, 125, 521, 1, 0, 0, 0, 127, 526, 1, 0, 0, 0, 129, 530, 1, 0, 0, 0, 131, 535, 1, 0, 0, 0, 133, 538, 1, 0, 0, 0, 135, 543, 1, 0, 0, 0, 137, 549, 1, 0, 0, 0, 139, 554, 1, 0, 0, 0, 141, 558, 1, 0, 0, 0, 143, 562, 1, 0, 0, 0, 145, 568, 1, 0, 0, 0, 147, 574, 1, 0, 0, 0, 149, 580, 1, 0, 0, 0, 151, 585, 1, 0, 0, 0, 153, 588, 1, 0, 0, 0, 155, 595, 1, 0, 0, 0, 157, 597, 1, 0, 0, 0, 159, 599, 1, 0, 0, 0, 161, 601, 1, 0, 0, 0, 163, 603, 1, 0, 0, 0, 165, 605, 1, 0, 0, 0, 167, 607, 1, 0, 0, 0, 169, 609, 1, 0, 0, 0, 171, 611, 1, 0, 0, 0, 173, 613, 1, 0, 0, 0, 175, 615, 1, 0, 0, 0, 177, 617, 1, 0, 0, 0, 179, 180, 5, 47, 0, 0, 180, 181, 5, 47, 0, 0, 181, 185, 1, 0, 0, 0, 182, 184, 8, 0, 0, 0, 183, 182, 1, 0, 0, 0, 184, 187, 1, 0, 0, 0, 185, 183, 1, 0, 0, 0, 185, 186, 1, 0, 0, 0, 186, 188, 1, 0, 0, 0, 187, 185, 1, 0, 0, 0, 188, 189, 6, 0, 0, 0, 189, 2, 1, 0, 0, 0, 190, 191, 5, 47, 0, 0, 191, 192, 5, 42, 0, 0, 192, 200, 1, 0, 0, 0, 193, 201, 8, 1, 0, 0, 194, 196, 5, 42, 0, 0, 195, 194, 1, 0, 0, 0, 196, 197, 1, 0, 0, 0, 197, 195, 1, 0, 0, 0, 197, 198, 1, 0, 0, 0, 198, 199, 1, 0, 0, 0, 199, 201, 8, 2, 0, 0, 200, 193, 1, 0, 0, 0, 200, 195, 1, 0, 0, 0, 201, 205, 1, 0, 0, 0, 202, 204, 5, 42, 0, 0, 203, 202, 1, 0, 0, 0, 204, 207, 1, 0, 0, 0, 205, 203, 1, 0, 0, 0, 205, 206, 1, 0, 0, 0, 206, 208, 1, 0, 0, 0, 207, 205, 1, 0, 0, 0, 208, 209, 5, 42, 0, 0, 209, 210, 5, 47, 0, 0, 210, 211, 1, 0, 0, 0, 211, 212, 6, 1, 0, 0, 212, 4, 1, 0, 0, 0, 213, 215, 7, 3, 0, 0, 214, 213, 1, 0, 0, 0, 215, 216, 1, 0, 0, 0, 216, 214, 1, 0, 0, 0, 216, 217, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 219, 6, 2, 0, 0, 219, 6, 1, 0, 0, 0, 220, 221, 7, 4, 0, 0, 221, 8, 1, 0, 0, 0, 222, 223, 7, 5, 0, 0, 223, 10, 1, 0, 0, 0, 224, 225, 7, 6, 0, 0, 225, 12, 1, 0, 0, 0, 226, 227, 7, 7, 0, 0, 227, 14, 1, 0, 0, 0, 228, 229, 7, 8, 0, 0, 229, 16, 1, 0, 0, 0, 230, 231, 7, 9, 0, 0, 231, 18, 1, 0, 0, 0, 232, 233, 7, 10, 0, 0, 233, 20, 1, 0, 0, 0, 234, 235, 7, 11, 0, 0, 235, 22, 1, 0, 0, 0, 236, 237, 7, 12, 0, 0, 237, 24, 1, 0, 0, 0, 238, 239, 7, 13, 0, 0, 239, 26, 1, 0, 0, 0, 240, 241, 7, 14, 0, 0, 241, 28, 1, 0, 0, 0, 242, 243, 7, 15, 0, 0, 243, 30, 1, 0, 0, 0, 244, 245, 7, 16, 0, 0, 245, 32, 1, 0, 0, 0, 246, 247, 7, 17, 0, 0, 247, 34, 1, 0, 0, 0, 248, 249, 7, 18, 0, 0, 249, 36, 1, 0, 0, 0, 250, 251, 7, 19, 0, 0, 251, 38, 1, 0, 0, 0, 252, 253, 7, 20, 0, 0, 253, 40, 1, 0, 0, 0, 254, 255, 7, 21, 0, 0, 255, 42, 1, 0, 0, 0, 256, 257, 7, 22, 0, 0, 257, 44, 1, 0, 0, 0, 258, 259, 7, 23, 0, 0, 259, 46, 1, 0, 0, 0, 260, 261, 7, 24, 0, 0, 261, 48, 1, 0, 0, 0, 262, 263, 7, 25, 0, 0, 263, 50, 1, 0, 0, 0, 264, 265, 7, 26, 0, 0, 265, 52, 1, 0, 0, 0, 266, 267, 7, 27, 0, 0, 267, 54, 1, 0, 0, 0, 268, 269, 7, 28, 0, 0, 269, 56, 1, 0, 0, 0, 270, 271, 7, 29, 0, 0, 271, 58, 1, 0, 0, 0, 272, 273, 7, 30, 0, 0, 273, 60, 1, 0, 0, 0, 274, 283, 5, 48, 0, 0, 275, 279, 7, 31, 0, 0, 276, 278, 7, 30, 0, 0, 277, 276, 1, 0, 0, 0, 278, 281, 1, 0, 0, 0, 279, 277, 1, 0, 0, 0, 279, 280, 1, 0, 0, 0, 280, 283, 1, 0, 0, 0, 281, 279, 1, 0, 0, 0, 282, 274, 1, 0, 0, 0, 282, 275, 1, 0, 0, 0, 283, 62, 1, 0, 0, 0, 284, 285, 3, 23, 11, 0, 285, 286, 3, 17, 8, 0, 286, 64, 1, 0, 0, 0, 287, 288, 3, 45, 22, 0, 288, 289, 3, 21, 10, 0, 289, 290, 3, 15, 7, 0, 290, 291, 3, 33, 16, 0, 291, 66, 1, 0, 0, 0, 292, 293, 3, 15, 7, 0, 293, 294, 3, 29, 14, 0, 294, 295, 3, 43, 21, 0, 295, 296, 3, 15, 7, 0, 296, 68, 1, 0, 0, 0, 297, 298, 3, 9, 4, 0, 298, 299, 3, 35, 17, 0, 299, 300, 3, 35, 17, 0, 300, 301, 3, 29, 14, 0, 301, 302, 3, 15, 7, 0, 302, 303, 3, 7, 3, 0, 303, 304, 3, 33, 16, 0, 304, 70, 1, 0, 0, 0, 305, 306, 3, 23, 11, 0, 306, 307, 5, 56, 0, 0, 307, 72, 1, 0, 0, 0, 308, 309, 3, 23, 11, 0, 309, 310, 5, 49, 0, 0, 310, 311, 5, 54, 0, 0, 311, 74, 1, 0, 0, 0, 312, 313, 3, 23, 11, 0, 313, 314, 5, 51, 0, 0, 314, 315, 5, 50, 0, 0, 315, 76, 1, 0, 0, 0, 316, 317, 3, 23, 11, 0, 317, 318, 5, 54, 0, 0, 318, 319, 5, 52, 0, 0, 319, 78, 1, 0, 0, 0, 320, 321, 3, 17, 8, 0, 321, 322, 3, 37, 18, 0, 322, 323, 5, 51, 0, 0, 323, 324, 5, 50, 0, 0, 324, 80, 1, 0, 0, 0, 325, 326, 3, 17, 8, 0, 326, 327, 3, 37, 18, 0, 327, 328, 5, 54, 0, 0, 328, 329, 5, 52, 0, 0, 329, 82, 1, 0, 0, 0, 330, 331, 3, 43, 21, 0, 331, 332, 3, 45, 22, 0, 332, 333, 3, 41, 20, 0, 333, 334, 3, 23, 11, 0, 334, 335, 3, 33, 16, 0, 335, 336, 3, 19, 9, 0, 336, 84, 1, 0, 0, 0, 337, 338, 3, 9, 4, 0, 338, 339, 3, 23, 11, 0, 339, 340, 3, 33, 16, 0, 340, 341, 3, 7, 3, 0, 341, 342, 3, 41, 20, 0, 342, 343, 3, 55, 27, 0, 343, 86, 1, 0, 0, 0, 344, 345, 3, 45, 22, 0, 345, 346, 3, 23, 11, 0, 346, 347, 3, 31, 15, 0, 347, 348, 3, 15, 7, 0, 348, 349, 3, 43, 21, 0, 349, 350, 3, 45, 22, 0, 350, 351, 3, 7, 3, 0, 351, 352, 3, 31, 15, 0, 352, 353, 3, 37, 18, 0, 353, 88, 1, 0, 0, 0, 354, 355, 3, 45, 22, 0, 355, 356, 3, 23, 11, 0, 356, 357, 3, 31, 15, 0, 357, 358, 3, 15, 7, 0, 358, 359, 3, 43, 21, 0, 359, 360, 3, 45, 22, 0, 360, 361, 3, 7, 3, 0, 361, 362, 3, 31, 15, 0, 362, 363, 3, 37, 18, 0, 363, 364, 5, 95, 0, 0, 364, 365, 3, 45, 22, 0, 365, 366, 3, 57, 28, 0, 366, 90, 1, 0, 0, 0, 367, 368, 3, 13, 6, 0, 368, 369, 3, 7, 3, 0, 369, 370, 3, 45, 22, 0, 370, 371, 3, 15, 7, 0, 371, 92, 1, 0, 0, 0, 372, 373, 3, 45, 22, 0, 373, 374, 3, 23, 11, 0, 374, 375, 3, 31, 15, 0, 375, 376, 3, 15, 7, 0, 376, 94, 1, 0, 0, 0, 377, 378, 3, 23, 11, 0, 378, 379, 3, 33, 16, 0, 379, 380, 3, 45, 22, 0, 380, 381, 3, 15, 7, 0, 381, 382, 3, 41, 20, 0, 382, 383, 3, 49, 24, 0, 383, 384, 3, 7, 3, 0, 384, 385, 3, 29, 14, 0, 385, 386, 5, 95, 0, 0, 386, 387, 3, 55, 27, 0, 387, 388, 3, 15, 7, 0, 388, 389, 3, 7, 3, 0, 389, 390, 3, 41, 20, 0, 390, 96, 1, 0, 0, 0, 391, 392, 3, 23, 11, 0, 392, 393, 3, 33, 16, 0, 393, 394, 3, 45, 22, 0, 394, 395, 3, 15, 7, 0, 395, 396, 3, 41, 20, 0, 396, 397, 3, 49, 24, 0, 397, 398, 3, 7, 3, 0, 398, 399, 3, 29, 14, 0, 399, 400, 5, 95, 0, 0, 400, 401, 3, 13, 6, 0, 401, 402, 3, 7, 3, 0, 402, 403, 3, 55, 27, 0, 403, 98, 1, 0, 0, 0, 404, 405, 3, 47, 23, 0, 405, 406, 3, 47, 23, 0, 406, 407, 3, 23, 11, 0, 407, 408, 3, 13, 6, 0, 408, 100, 1, 0, 0, 0, 409, 410, 3, 13, 6, 0, 410, 411, 3, 15, 7, 0, 411, 412, 3, 11, 5, 0, 412, 413, 3, 23, 11, 0, 413, 414, 3, 31, 15, 0, 414, 415, 3, 7, 3, 0, 415, 416, 3, 29, 14, 0, 416, 102, 1, 0, 0, 0, 417, 418, 3, 37, 18, 0, 418, 419, 3, 41, 20, 0, 419, 420, 3, 15, 7, 0, 420, 421, 3, 11, 5, 0, 421, 422, 3, 23, 11, 0, 422, 423, 3, 43, 21, 0, 423, 424, 3, 23, 11, 0, 424, 425, 3, 35, 17, 0, 425, 426, 3, 33, 16, 0, 426, 427, 5, 95, 0, 0, 427, 428, 3, 45, 22, 0, 428, 429, 3, 23, 11, 0, 429, 430, 3, 31, 15, 0, 430, 431, 3, 15, 7, 0, 431, 432, 3, 43, 21, 0, 432, 433, 3, 45, 22, 0, 433, 434, 3, 7, 3, 0, 434, 435, 3, 31, 15, 0, 435, 436, 3, 37, 18, 0, 436, 104, 1, 0, 0, 0, 437, 438, 3, 37, 18, 0, 438, 439, 3, 41, 20, 0, 439, 440, 3, 15, 7, 0, 440, 441, 3, 11, 5, 0, 441, 442, 3, 23, 11, 0, 442, 443, 3, 43, 21, 0, 443, 444, 3, 23, 11, 0, 444, 445, 3, 35, 17, 0, 445, 446, 3, 33, 16, 0, 446, 447, 5, 95, 0, 0, 447, 448, 3, 45, 22, 0, 448, 449, 3, 23, 11, 0, 449, 450, 3, 31, 15, 0, 450, 451, 3, 15, 7, 0, 451, 452, 3, 43, 21, 0, 452, 453, 3, 45, 22, 0, 453, 454, 3, 7, 3, 0, 454, 455, 3, 31, 15, 0, 455, 456, 3, 37, 18, 0, 456, 457, 5, 95, 0, 0, 457, 458, 3, 45, 22, 0, 458, 459, 3, 57, 28, 0, 459, 106, 1, 0, 0, 0, 460, 461, 3, 17, 8, 0, 461, 462, 3, 23, 11, 0, 462, 463, 3, 53, 26, 0, 463, 464, 3, 15, 7, 0, 464, 465, 3, 13, 6, 0, 465, 466, 3, 11, 5, 0, 466, 467, 3, 21, 10, 0, 467, 468, 3, 7, 3, 0, 468, 469, 3, 41, 20, 0, 469, 108, 1, 0, 0, 0, 470, 471, 3, 49, 24, 0, 471, 472, 3, 7, 3, 0, 472, 473, 3, 41, 20, 0, 473, 474, 3, 11, 5, 0, 474, 475, 3, 21, 10, 0, 475, 476, 3, 7, 3, 0, 476, 477, 3, 41, 20, 0, 477, 110, 1, 0, 0, 0, 478, 479, 3, 17, 8, 0, 479, 480, 3, 23, 11, 0, 480, 481, 3, 53, 26, 0, 481, 482, 3, 15, 7, 0, 482, 483, 3, 13, 6, 0, 483, 484, 3, 9, 4, 0, 484, 485, 3, 23, 11, 0, 485, 486, 3, 33, 16, 0, 486, 487, 3, 7, 3, 0, 487, 488, 3, 41, 20, 0, 488, 489, 3, 55, 27, 0, 489, 112, 1, 0, 0, 0, 490, 491, 3, 43, 21, 0, 491, 492, 3, 45, 22, 0, 492, 493, 3, 41, 20, 0, 493, 494, 3, 47, 23, 0, 494, 495, 3, 11, 5, 0, 495, 496, 3, 45, 22, 0, 496, 114, 1, 0, 0, 0, 497, 498, 3, 33, 16, 0, 498, 499, 3, 43, 21, 0, 499, 500, 3, 45, 22, 0, 500, 501, 3, 41, 20, 0, 501, 502, 3, 47, 23, 0, 502, 503, 3, 11, 5, 0, 503, 504, 3, 45, 22, 0, 504, 116, 1, 0, 0, 0, 505, 506, 3, 29, 14, 0, 506, 507, 3, 23, 11, 0, 507, 508, 3, 43, 21, 0, 508, 509, 3, 45, 22, 0, 509, 118, 1, 0, 0, 0, 510, 511, 3, 31, 15, 0, 511, 512, 3, 7, 3, 0, 512, 513, 3, 37, 18, 0, 513, 120, 1, 0, 0, 0, 514, 515, 3, 7, 3, 0, 515, 516, 3, 33, 16, 0, 516, 517, 3, 55, 27, 0, 517, 122, 1, 0, 0, 0, 518, 519, 3, 47, 23, 0, 519, 520, 5, 33, 0, 0, 520, 124, 1, 0, 0, 0, 521, 522, 3, 9, 4, 0, 522, 523, 3, 35, 17, 0, 523, 524, 3, 35, 17, 0, 524, 525, 3, 29, 14, 0, 525, 126, 1, 0, 0, 0, 526, 527, 3, 43, 21, 0, 527, 528, 3, 45, 22, 0, 528, 529, 3, 41, 20, 0, 529, 128, 1, 0, 0, 0, 530, 531, 3, 49, 24, 0, 531, 532, 3, 9, 4, 0, 532, 533, 3, 23, 11, 0, 533, 534, 3, 33, 16, 0, 534, 130, 1, 0, 0, 0, 535, 536, 3, 45, 22, 0, 536, 537, 3, 43, 21, 0, 537, 132, 1, 0, 0, 0, 538, 539, 3, 45, 22, 0, 539, 540, 3, 43, 21, 0, 540, 541, 3, 45, 22, 0, 541, 542, 3, 57, 28, 0, 542, 134, 1, 0, 0, 0, 543, 544, 3, 23, 11, 0, 544, 545, 3, 55, 27, 0, 545, 546, 3, 15, 7, 0, 546, 547, 3, 7, 3, 0, 547, 548, 3, 41, 20, 0, 548, 136, 1, 0, 0, 0, 549, 550, 3, 23, 11, 0, 550, 551, 3, 13, 6, 0, 551, 552, 3, 7, 3, 0, 552, 553, 3, 55, 27, 0, 553, 138, 1, 0, 0, 0, 554, 555, 3, 13, 6, 0, 555, 556, 3, 15, 7, 0, 556, 557, 3, 11, 5, 0, 557, 140, 1, 0, 0, 0, 558, 559, 3, 37, 18, 0, 559, 560, 3, 45, 22, 0, 560, 561, 3, 43, 21, 0, 561, 142, 1, 0, 0, 0, 562, 563, 3, 37, 18, 0, 563, 564, 3, 45, 22, 0, 564, 565, 3, 43, 21, 0, 565, 566, 3, 45, 22, 0, 566, 567, 3, 57, 28, 0, 567, 144, 1, 0, 0, 0, 568, 569, 3, 17, 8, 0, 569, 570, 3, 11, 5, 0, 570, 571, 3, 21, 10, 0, 571, 572, 3, 7, 3, 0, 572, 573, 3, 41, 20, 0, 573, 146, 1, 0, 0, 0, 574, 575, 3, 49, 24, 0, 575, 576, 3, 11, 5, 0, 576, 577, 3, 21, 10, 0, 577, 578, 3, 7, 3, 0, 578, 579, 3, 41, 20, 0, 579, 148, 1, 0, 0, 0, 580, 581, 3, 17, 8, 0, 581, 582, 3, 9, 4, 0, 582, 583, 3, 23, 11, 0, 583, 584, 3, 33, 16, 0, 584, 150, 1, 0, 0, 0, 585, 586, 5, 58, 0, 0, 586, 587, 5, 58, 0, 0, 587, 152, 1, 0, 0, 0, 588, 592, 7, 32, 0, 0, 589, 591, 7, 33, 0, 0, 590, 589, 1, 0, 0, 0, 591, 594, 1, 0, 0, 0, 592, 590, 1, 0, 0, 0, 592, 593, 1, 0, 0, 0, 593, 154, 1, 0, 0, 0, 594, 592, 1, 0, 0, 0, 595, 596, 5, 60, 0, 0, 596, 156, 1, 0, 0, 0, 597, 598, 5, 62, 0, 0, 598, 158, 1, 0, 0, 0, 599, 600, 5, 40, 0, 0, 600, 160, 1, 0, 0, 0, 601, 602, 5, 41, 0, 0, 602, 162, 1, 0, 0, 0, 603, 604, 5, 91, 0, 0, 604, 164, 1, 0, 0, 0, 605, 606, 5, 93, 0, 0, 606, 166, 1, 0, 0, 0, 607, 608, 5, 44, 0, 0, 608, 168, 1, 0, 0, 0, 609, 610, 5, 61, 0, 0, 610, 170, 1, 0, 0, 0, 611, 612, 5, 58, 0, 0, 612, 172, 1, 0, 0, 0, 613, 614, 5, 63, 0, 0, 614, 174, 1, 0, 0, 0, 615, 616, 5, 35, 0, 0, 616, 176, 1, 0, 0, 0, 617, 618, 5, 46, 0, 0, 618, 178, 1, 0, 0, 0, 9, 0, 185, 197, 200, 205, 216, 279, 282, 592, 1, 0, 1, 0] \ No newline at end of file diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py new file mode 100644 index 000000000..bbb0f0de1 --- /dev/null +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -0,0 +1,344 @@ +# Generated from SubstraitLexer.g4 by ANTLR 4.13.2 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + return [ + 4,0,61,619,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, + 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, + 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, + 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, + 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, + 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, + 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, + 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, + 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, + 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, + 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, + 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, + 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, + 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,1,0,1,0,1,0,1,0,5,0,184, + 8,0,10,0,12,0,187,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,4,1,196,8,1,11, + 1,12,1,197,1,1,3,1,201,8,1,1,1,5,1,204,8,1,10,1,12,1,207,9,1,1,1, + 1,1,1,1,1,1,1,1,1,2,4,2,215,8,2,11,2,12,2,216,1,2,1,2,1,3,1,3,1, + 4,1,4,1,5,1,5,1,6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10,1,10,1,11,1,11, + 1,12,1,12,1,13,1,13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18, + 1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1,23,1,23,1,24,1,24, + 1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30,1,30,1,30, + 5,30,278,8,30,10,30,12,30,281,9,30,3,30,283,8,30,1,31,1,31,1,31, + 1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,33,1,34,1,34,1,34, + 1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,37, + 1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,1,40, + 1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,42,1,42, + 1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43, + 1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,1,47, + 1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47, + 1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48, + 1,49,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, + 1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51, + 1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53, + 1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55, + 1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56, + 1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,58,1,58,1,58, + 1,58,1,58,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,61,1,61,1,61, + 1,62,1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64, + 1,64,1,65,1,65,1,65,1,66,1,66,1,66,1,66,1,66,1,67,1,67,1,67,1,67, + 1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,69,1,69,1,69,1,69,1,70,1,70, + 1,70,1,70,1,71,1,71,1,71,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72, + 1,72,1,73,1,73,1,73,1,73,1,73,1,73,1,74,1,74,1,74,1,74,1,74,1,75, + 1,75,1,75,1,76,1,76,5,76,591,8,76,10,76,12,76,594,9,76,1,77,1,77, + 1,78,1,78,1,79,1,79,1,80,1,80,1,81,1,81,1,82,1,82,1,83,1,83,1,84, + 1,84,1,85,1,85,1,86,1,86,1,87,1,87,1,88,1,88,0,0,89,1,1,3,2,5,3, + 7,0,9,0,11,0,13,0,15,0,17,0,19,0,21,0,23,0,25,0,27,0,29,0,31,0,33, + 0,35,0,37,0,39,0,41,0,43,0,45,0,47,0,49,0,51,0,53,0,55,0,57,0,59, + 0,61,0,63,4,65,5,67,6,69,7,71,8,73,9,75,10,77,11,79,12,81,13,83, + 14,85,15,87,16,89,17,91,18,93,19,95,20,97,21,99,22,101,23,103,24, + 105,25,107,26,109,27,111,28,113,29,115,30,117,31,119,32,121,33,123, + 34,125,35,127,36,129,37,131,38,133,39,135,40,137,41,139,42,141,43, + 143,44,145,45,147,46,149,47,151,48,153,49,155,50,157,51,159,52,161, + 53,163,54,165,55,167,56,169,57,171,58,173,59,175,60,177,61,1,0,34, + 2,0,10,10,13,13,1,0,42,42,2,0,42,42,47,47,3,0,9,10,13,13,32,32,2, + 0,65,65,97,97,2,0,66,66,98,98,2,0,67,67,99,99,2,0,68,68,100,100, + 2,0,69,69,101,101,2,0,70,70,102,102,2,0,71,71,103,103,2,0,72,72, + 104,104,2,0,73,73,105,105,2,0,74,74,106,106,2,0,75,75,107,107,2, + 0,76,76,108,108,2,0,77,77,109,109,2,0,78,78,110,110,2,0,79,79,111, + 111,2,0,80,80,112,112,2,0,81,81,113,113,2,0,82,82,114,114,2,0,83, + 83,115,115,2,0,84,84,116,116,2,0,85,85,117,117,2,0,86,86,118,118, + 2,0,87,87,119,119,2,0,88,88,120,120,2,0,89,89,121,121,2,0,90,90, + 122,122,1,0,48,57,1,0,49,57,3,0,65,90,95,95,97,122,4,0,48,57,65, + 90,95,95,97,122,598,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,63,1,0, + 0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0, + 0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0, + 0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0, + 0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1, + 0,0,0,0,105,1,0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0, + 113,1,0,0,0,0,115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0, + 0,0,0,123,1,0,0,0,0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131, + 1,0,0,0,0,133,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0, + 0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1, + 0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157,1,0,0,0,0, + 159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0,167,1,0, + 0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0,177, + 1,0,0,0,1,179,1,0,0,0,3,190,1,0,0,0,5,214,1,0,0,0,7,220,1,0,0,0, + 9,222,1,0,0,0,11,224,1,0,0,0,13,226,1,0,0,0,15,228,1,0,0,0,17,230, + 1,0,0,0,19,232,1,0,0,0,21,234,1,0,0,0,23,236,1,0,0,0,25,238,1,0, + 0,0,27,240,1,0,0,0,29,242,1,0,0,0,31,244,1,0,0,0,33,246,1,0,0,0, + 35,248,1,0,0,0,37,250,1,0,0,0,39,252,1,0,0,0,41,254,1,0,0,0,43,256, + 1,0,0,0,45,258,1,0,0,0,47,260,1,0,0,0,49,262,1,0,0,0,51,264,1,0, + 0,0,53,266,1,0,0,0,55,268,1,0,0,0,57,270,1,0,0,0,59,272,1,0,0,0, + 61,282,1,0,0,0,63,284,1,0,0,0,65,287,1,0,0,0,67,292,1,0,0,0,69,297, + 1,0,0,0,71,305,1,0,0,0,73,308,1,0,0,0,75,312,1,0,0,0,77,316,1,0, + 0,0,79,320,1,0,0,0,81,325,1,0,0,0,83,330,1,0,0,0,85,337,1,0,0,0, + 87,344,1,0,0,0,89,354,1,0,0,0,91,367,1,0,0,0,93,372,1,0,0,0,95,377, + 1,0,0,0,97,391,1,0,0,0,99,404,1,0,0,0,101,409,1,0,0,0,103,417,1, + 0,0,0,105,437,1,0,0,0,107,460,1,0,0,0,109,470,1,0,0,0,111,478,1, + 0,0,0,113,490,1,0,0,0,115,497,1,0,0,0,117,505,1,0,0,0,119,510,1, + 0,0,0,121,514,1,0,0,0,123,518,1,0,0,0,125,521,1,0,0,0,127,526,1, + 0,0,0,129,530,1,0,0,0,131,535,1,0,0,0,133,538,1,0,0,0,135,543,1, + 0,0,0,137,549,1,0,0,0,139,554,1,0,0,0,141,558,1,0,0,0,143,562,1, + 0,0,0,145,568,1,0,0,0,147,574,1,0,0,0,149,580,1,0,0,0,151,585,1, + 0,0,0,153,588,1,0,0,0,155,595,1,0,0,0,157,597,1,0,0,0,159,599,1, + 0,0,0,161,601,1,0,0,0,163,603,1,0,0,0,165,605,1,0,0,0,167,607,1, + 0,0,0,169,609,1,0,0,0,171,611,1,0,0,0,173,613,1,0,0,0,175,615,1, + 0,0,0,177,617,1,0,0,0,179,180,5,47,0,0,180,181,5,47,0,0,181,185, + 1,0,0,0,182,184,8,0,0,0,183,182,1,0,0,0,184,187,1,0,0,0,185,183, + 1,0,0,0,185,186,1,0,0,0,186,188,1,0,0,0,187,185,1,0,0,0,188,189, + 6,0,0,0,189,2,1,0,0,0,190,191,5,47,0,0,191,192,5,42,0,0,192,200, + 1,0,0,0,193,201,8,1,0,0,194,196,5,42,0,0,195,194,1,0,0,0,196,197, + 1,0,0,0,197,195,1,0,0,0,197,198,1,0,0,0,198,199,1,0,0,0,199,201, + 8,2,0,0,200,193,1,0,0,0,200,195,1,0,0,0,201,205,1,0,0,0,202,204, + 5,42,0,0,203,202,1,0,0,0,204,207,1,0,0,0,205,203,1,0,0,0,205,206, + 1,0,0,0,206,208,1,0,0,0,207,205,1,0,0,0,208,209,5,42,0,0,209,210, + 5,47,0,0,210,211,1,0,0,0,211,212,6,1,0,0,212,4,1,0,0,0,213,215,7, + 3,0,0,214,213,1,0,0,0,215,216,1,0,0,0,216,214,1,0,0,0,216,217,1, + 0,0,0,217,218,1,0,0,0,218,219,6,2,0,0,219,6,1,0,0,0,220,221,7,4, + 0,0,221,8,1,0,0,0,222,223,7,5,0,0,223,10,1,0,0,0,224,225,7,6,0,0, + 225,12,1,0,0,0,226,227,7,7,0,0,227,14,1,0,0,0,228,229,7,8,0,0,229, + 16,1,0,0,0,230,231,7,9,0,0,231,18,1,0,0,0,232,233,7,10,0,0,233,20, + 1,0,0,0,234,235,7,11,0,0,235,22,1,0,0,0,236,237,7,12,0,0,237,24, + 1,0,0,0,238,239,7,13,0,0,239,26,1,0,0,0,240,241,7,14,0,0,241,28, + 1,0,0,0,242,243,7,15,0,0,243,30,1,0,0,0,244,245,7,16,0,0,245,32, + 1,0,0,0,246,247,7,17,0,0,247,34,1,0,0,0,248,249,7,18,0,0,249,36, + 1,0,0,0,250,251,7,19,0,0,251,38,1,0,0,0,252,253,7,20,0,0,253,40, + 1,0,0,0,254,255,7,21,0,0,255,42,1,0,0,0,256,257,7,22,0,0,257,44, + 1,0,0,0,258,259,7,23,0,0,259,46,1,0,0,0,260,261,7,24,0,0,261,48, + 1,0,0,0,262,263,7,25,0,0,263,50,1,0,0,0,264,265,7,26,0,0,265,52, + 1,0,0,0,266,267,7,27,0,0,267,54,1,0,0,0,268,269,7,28,0,0,269,56, + 1,0,0,0,270,271,7,29,0,0,271,58,1,0,0,0,272,273,7,30,0,0,273,60, + 1,0,0,0,274,283,5,48,0,0,275,279,7,31,0,0,276,278,7,30,0,0,277,276, + 1,0,0,0,278,281,1,0,0,0,279,277,1,0,0,0,279,280,1,0,0,0,280,283, + 1,0,0,0,281,279,1,0,0,0,282,274,1,0,0,0,282,275,1,0,0,0,283,62,1, + 0,0,0,284,285,3,23,11,0,285,286,3,17,8,0,286,64,1,0,0,0,287,288, + 3,45,22,0,288,289,3,21,10,0,289,290,3,15,7,0,290,291,3,33,16,0,291, + 66,1,0,0,0,292,293,3,15,7,0,293,294,3,29,14,0,294,295,3,43,21,0, + 295,296,3,15,7,0,296,68,1,0,0,0,297,298,3,9,4,0,298,299,3,35,17, + 0,299,300,3,35,17,0,300,301,3,29,14,0,301,302,3,15,7,0,302,303,3, + 7,3,0,303,304,3,33,16,0,304,70,1,0,0,0,305,306,3,23,11,0,306,307, + 5,56,0,0,307,72,1,0,0,0,308,309,3,23,11,0,309,310,5,49,0,0,310,311, + 5,54,0,0,311,74,1,0,0,0,312,313,3,23,11,0,313,314,5,51,0,0,314,315, + 5,50,0,0,315,76,1,0,0,0,316,317,3,23,11,0,317,318,5,54,0,0,318,319, + 5,52,0,0,319,78,1,0,0,0,320,321,3,17,8,0,321,322,3,37,18,0,322,323, + 5,51,0,0,323,324,5,50,0,0,324,80,1,0,0,0,325,326,3,17,8,0,326,327, + 3,37,18,0,327,328,5,54,0,0,328,329,5,52,0,0,329,82,1,0,0,0,330,331, + 3,43,21,0,331,332,3,45,22,0,332,333,3,41,20,0,333,334,3,23,11,0, + 334,335,3,33,16,0,335,336,3,19,9,0,336,84,1,0,0,0,337,338,3,9,4, + 0,338,339,3,23,11,0,339,340,3,33,16,0,340,341,3,7,3,0,341,342,3, + 41,20,0,342,343,3,55,27,0,343,86,1,0,0,0,344,345,3,45,22,0,345,346, + 3,23,11,0,346,347,3,31,15,0,347,348,3,15,7,0,348,349,3,43,21,0,349, + 350,3,45,22,0,350,351,3,7,3,0,351,352,3,31,15,0,352,353,3,37,18, + 0,353,88,1,0,0,0,354,355,3,45,22,0,355,356,3,23,11,0,356,357,3,31, + 15,0,357,358,3,15,7,0,358,359,3,43,21,0,359,360,3,45,22,0,360,361, + 3,7,3,0,361,362,3,31,15,0,362,363,3,37,18,0,363,364,5,95,0,0,364, + 365,3,45,22,0,365,366,3,57,28,0,366,90,1,0,0,0,367,368,3,13,6,0, + 368,369,3,7,3,0,369,370,3,45,22,0,370,371,3,15,7,0,371,92,1,0,0, + 0,372,373,3,45,22,0,373,374,3,23,11,0,374,375,3,31,15,0,375,376, + 3,15,7,0,376,94,1,0,0,0,377,378,3,23,11,0,378,379,3,33,16,0,379, + 380,3,45,22,0,380,381,3,15,7,0,381,382,3,41,20,0,382,383,3,49,24, + 0,383,384,3,7,3,0,384,385,3,29,14,0,385,386,5,95,0,0,386,387,3,55, + 27,0,387,388,3,15,7,0,388,389,3,7,3,0,389,390,3,41,20,0,390,96,1, + 0,0,0,391,392,3,23,11,0,392,393,3,33,16,0,393,394,3,45,22,0,394, + 395,3,15,7,0,395,396,3,41,20,0,396,397,3,49,24,0,397,398,3,7,3,0, + 398,399,3,29,14,0,399,400,5,95,0,0,400,401,3,13,6,0,401,402,3,7, + 3,0,402,403,3,55,27,0,403,98,1,0,0,0,404,405,3,47,23,0,405,406,3, + 47,23,0,406,407,3,23,11,0,407,408,3,13,6,0,408,100,1,0,0,0,409,410, + 3,13,6,0,410,411,3,15,7,0,411,412,3,11,5,0,412,413,3,23,11,0,413, + 414,3,31,15,0,414,415,3,7,3,0,415,416,3,29,14,0,416,102,1,0,0,0, + 417,418,3,37,18,0,418,419,3,41,20,0,419,420,3,15,7,0,420,421,3,11, + 5,0,421,422,3,23,11,0,422,423,3,43,21,0,423,424,3,23,11,0,424,425, + 3,35,17,0,425,426,3,33,16,0,426,427,5,95,0,0,427,428,3,45,22,0,428, + 429,3,23,11,0,429,430,3,31,15,0,430,431,3,15,7,0,431,432,3,43,21, + 0,432,433,3,45,22,0,433,434,3,7,3,0,434,435,3,31,15,0,435,436,3, + 37,18,0,436,104,1,0,0,0,437,438,3,37,18,0,438,439,3,41,20,0,439, + 440,3,15,7,0,440,441,3,11,5,0,441,442,3,23,11,0,442,443,3,43,21, + 0,443,444,3,23,11,0,444,445,3,35,17,0,445,446,3,33,16,0,446,447, + 5,95,0,0,447,448,3,45,22,0,448,449,3,23,11,0,449,450,3,31,15,0,450, + 451,3,15,7,0,451,452,3,43,21,0,452,453,3,45,22,0,453,454,3,7,3,0, + 454,455,3,31,15,0,455,456,3,37,18,0,456,457,5,95,0,0,457,458,3,45, + 22,0,458,459,3,57,28,0,459,106,1,0,0,0,460,461,3,17,8,0,461,462, + 3,23,11,0,462,463,3,53,26,0,463,464,3,15,7,0,464,465,3,13,6,0,465, + 466,3,11,5,0,466,467,3,21,10,0,467,468,3,7,3,0,468,469,3,41,20,0, + 469,108,1,0,0,0,470,471,3,49,24,0,471,472,3,7,3,0,472,473,3,41,20, + 0,473,474,3,11,5,0,474,475,3,21,10,0,475,476,3,7,3,0,476,477,3,41, + 20,0,477,110,1,0,0,0,478,479,3,17,8,0,479,480,3,23,11,0,480,481, + 3,53,26,0,481,482,3,15,7,0,482,483,3,13,6,0,483,484,3,9,4,0,484, + 485,3,23,11,0,485,486,3,33,16,0,486,487,3,7,3,0,487,488,3,41,20, + 0,488,489,3,55,27,0,489,112,1,0,0,0,490,491,3,43,21,0,491,492,3, + 45,22,0,492,493,3,41,20,0,493,494,3,47,23,0,494,495,3,11,5,0,495, + 496,3,45,22,0,496,114,1,0,0,0,497,498,3,33,16,0,498,499,3,43,21, + 0,499,500,3,45,22,0,500,501,3,41,20,0,501,502,3,47,23,0,502,503, + 3,11,5,0,503,504,3,45,22,0,504,116,1,0,0,0,505,506,3,29,14,0,506, + 507,3,23,11,0,507,508,3,43,21,0,508,509,3,45,22,0,509,118,1,0,0, + 0,510,511,3,31,15,0,511,512,3,7,3,0,512,513,3,37,18,0,513,120,1, + 0,0,0,514,515,3,7,3,0,515,516,3,33,16,0,516,517,3,55,27,0,517,122, + 1,0,0,0,518,519,3,47,23,0,519,520,5,33,0,0,520,124,1,0,0,0,521,522, + 3,9,4,0,522,523,3,35,17,0,523,524,3,35,17,0,524,525,3,29,14,0,525, + 126,1,0,0,0,526,527,3,43,21,0,527,528,3,45,22,0,528,529,3,41,20, + 0,529,128,1,0,0,0,530,531,3,49,24,0,531,532,3,9,4,0,532,533,3,23, + 11,0,533,534,3,33,16,0,534,130,1,0,0,0,535,536,3,45,22,0,536,537, + 3,43,21,0,537,132,1,0,0,0,538,539,3,45,22,0,539,540,3,43,21,0,540, + 541,3,45,22,0,541,542,3,57,28,0,542,134,1,0,0,0,543,544,3,23,11, + 0,544,545,3,55,27,0,545,546,3,15,7,0,546,547,3,7,3,0,547,548,3,41, + 20,0,548,136,1,0,0,0,549,550,3,23,11,0,550,551,3,13,6,0,551,552, + 3,7,3,0,552,553,3,55,27,0,553,138,1,0,0,0,554,555,3,13,6,0,555,556, + 3,15,7,0,556,557,3,11,5,0,557,140,1,0,0,0,558,559,3,37,18,0,559, + 560,3,45,22,0,560,561,3,43,21,0,561,142,1,0,0,0,562,563,3,37,18, + 0,563,564,3,45,22,0,564,565,3,43,21,0,565,566,3,45,22,0,566,567, + 3,57,28,0,567,144,1,0,0,0,568,569,3,17,8,0,569,570,3,11,5,0,570, + 571,3,21,10,0,571,572,3,7,3,0,572,573,3,41,20,0,573,146,1,0,0,0, + 574,575,3,49,24,0,575,576,3,11,5,0,576,577,3,21,10,0,577,578,3,7, + 3,0,578,579,3,41,20,0,579,148,1,0,0,0,580,581,3,17,8,0,581,582,3, + 9,4,0,582,583,3,23,11,0,583,584,3,33,16,0,584,150,1,0,0,0,585,586, + 5,58,0,0,586,587,5,58,0,0,587,152,1,0,0,0,588,592,7,32,0,0,589,591, + 7,33,0,0,590,589,1,0,0,0,591,594,1,0,0,0,592,590,1,0,0,0,592,593, + 1,0,0,0,593,154,1,0,0,0,594,592,1,0,0,0,595,596,5,60,0,0,596,156, + 1,0,0,0,597,598,5,62,0,0,598,158,1,0,0,0,599,600,5,40,0,0,600,160, + 1,0,0,0,601,602,5,41,0,0,602,162,1,0,0,0,603,604,5,91,0,0,604,164, + 1,0,0,0,605,606,5,93,0,0,606,166,1,0,0,0,607,608,5,44,0,0,608,168, + 1,0,0,0,609,610,5,61,0,0,610,170,1,0,0,0,611,612,5,58,0,0,612,172, + 1,0,0,0,613,614,5,63,0,0,614,174,1,0,0,0,615,616,5,35,0,0,616,176, + 1,0,0,0,617,618,5,46,0,0,618,178,1,0,0,0,9,0,185,197,200,205,216, + 279,282,592,1,0,1,0 + ] + +class SubstraitLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + LineComment = 1 + BlockComment = 2 + Whitespace = 3 + If = 4 + Then = 5 + Else = 6 + Boolean = 7 + I8 = 8 + I16 = 9 + I32 = 10 + I64 = 11 + FP32 = 12 + FP64 = 13 + String = 14 + Binary = 15 + Timestamp = 16 + TimestampTZ = 17 + Date = 18 + Time = 19 + IntervalYear = 20 + IntervalDay = 21 + UUID = 22 + Decimal = 23 + PrecisionTimestamp = 24 + PrecisionTimestampTZ = 25 + FixedChar = 26 + VarChar = 27 + FixedBinary = 28 + Struct = 29 + NStruct = 30 + List = 31 + Map = 32 + ANY = 33 + UserDefined = 34 + Bool = 35 + Str = 36 + VBin = 37 + Ts = 38 + TsTZ = 39 + IYear = 40 + IDay = 41 + Dec = 42 + PTs = 43 + PTsTZ = 44 + FChar = 45 + VChar = 46 + FBin = 47 + DOUBLE_COLON = 48 + IDENTIFIER = 49 + O_ANGLE_BRACKET = 50 + C_ANGLE_BRACKET = 51 + OPAREN = 52 + CPAREN = 53 + OBRACKET = 54 + CBRACKET = 55 + COMMA = 56 + EQ = 57 + COLON = 58 + QMARK = 59 + HASH = 60 + DOT = 61 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", + "':'", "'?'", "'#'", "'.'" ] + + symbolicNames = [ "", + "LineComment", "BlockComment", "Whitespace", "If", "Then", "Else", + "Boolean", "I8", "I16", "I32", "I64", "FP32", "FP64", "String", + "Binary", "Timestamp", "TimestampTZ", "Date", "Time", "IntervalYear", + "IntervalDay", "UUID", "Decimal", "PrecisionTimestamp", "PrecisionTimestampTZ", + "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", + "List", "Map", "ANY", "UserDefined", "Bool", "Str", "VBin", + "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", "FChar", + "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", + "COMMA", "EQ", "COLON", "QMARK", "HASH", "DOT" ] + + ruleNames = [ "LineComment", "BlockComment", "Whitespace", "A", "B", + "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", + "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", + "Y", "Z", "DIGIT", "INTEGER", "If", "Then", "Else", "Boolean", + "I8", "I16", "I32", "I64", "FP32", "FP64", "String", "Binary", + "Timestamp", "TimestampTZ", "Date", "Time", "IntervalYear", + "IntervalDay", "UUID", "Decimal", "PrecisionTimestamp", + "PrecisionTimestampTZ", "FixedChar", "VarChar", "FixedBinary", + "Struct", "NStruct", "List", "Map", "ANY", "UserDefined", + "Bool", "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", + "Dec", "PTs", "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", + "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", + "CPAREN", "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", + "QMARK", "HASH", "DOT" ] + + grammarFileName = "SubstraitLexer.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/tests/coverage/antlr_parser/SubstraitLexer.tokens b/tests/coverage/antlr_parser/SubstraitLexer.tokens new file mode 100644 index 000000000..0757be1e2 --- /dev/null +++ b/tests/coverage/antlr_parser/SubstraitLexer.tokens @@ -0,0 +1,74 @@ +LineComment=1 +BlockComment=2 +Whitespace=3 +If=4 +Then=5 +Else=6 +Boolean=7 +I8=8 +I16=9 +I32=10 +I64=11 +FP32=12 +FP64=13 +String=14 +Binary=15 +Timestamp=16 +TimestampTZ=17 +Date=18 +Time=19 +IntervalYear=20 +IntervalDay=21 +UUID=22 +Decimal=23 +PrecisionTimestamp=24 +PrecisionTimestampTZ=25 +FixedChar=26 +VarChar=27 +FixedBinary=28 +Struct=29 +NStruct=30 +List=31 +Map=32 +ANY=33 +UserDefined=34 +Bool=35 +Str=36 +VBin=37 +Ts=38 +TsTZ=39 +IYear=40 +IDay=41 +Dec=42 +PTs=43 +PTsTZ=44 +FChar=45 +VChar=46 +FBin=47 +DOUBLE_COLON=48 +IDENTIFIER=49 +O_ANGLE_BRACKET=50 +C_ANGLE_BRACKET=51 +OPAREN=52 +CPAREN=53 +OBRACKET=54 +CBRACKET=55 +COMMA=56 +EQ=57 +COLON=58 +QMARK=59 +HASH=60 +DOT=61 +'::'=48 +'<'=50 +'>'=51 +'('=52 +')'=53 +'['=54 +']'=55 +','=56 +'='=57 +':'=58 +'?'=59 +'#'=60 +'.'=61 diff --git a/tests/coverage/antlr_parser/TestFileLexer.interp b/tests/coverage/antlr_parser/TestFileLexer.interp new file mode 100644 index 000000000..18f88403e --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileLexer.interp @@ -0,0 +1,330 @@ +token literal names: +null +'### SUBSTRAIT_SCALAR_TEST:' +null +'### SUBSTRAIT_INCLUDE:' +null +'' +'' +'overlfow' +'rounding' +'ERROR' +'SATURATE' +'SILENT' +'TIE_TO_EVEN' +'NAN' +null +null +null +null +null +null +null +null +'P' +'T' +'Y' +'M' +'D' +'H' +'S' +'F' +null +null +'null' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'::' +null +'<' +'>' +'(' +')' +'[' +']' +',' +'=' +':' +'?' +'#' +'.' + +token symbolic names: +null +SUBSTRAIT_SCALAR_TEST +FORMAT_VERSION +SUBSTRAIT_INCLUDE +DESCRIPTION_LINE +ERROR_RESULT +UNDEFINED_RESULT +OVERFLOW +ROUNDING +ERROR +SATURATE +SILENT +TIE_TO_EVEN +NAN +INTEGER_LITERAL +DECIMAL_LITERAL +FLOAT_LITERAL +BOOLEAN_LITERAL +TIMESTAMP_TZ_LITERAL +TIMESTAMP_LITERAL +TIME_LITERAL +DATE_LITERAL +PERIOD_PREFIX +TIME_PREFIX +YEAR_SUFFIX +M_SUFFIX +DAY_SUFFIX +HOUR_SUFFIX +SECOND_SUFFIX +FRACTIONAL_SECOND_SUFFIX +INTERVAL_YEAR_LITERAL +INTERVAL_DAY_LITERAL +NULL_LITERAL +STRING_LITERAL +LineComment +BlockComment +Whitespace +If +Then +Else +Boolean +I8 +I16 +I32 +I64 +FP32 +FP64 +String +Binary +Timestamp +TimestampTZ +Date +Time +IntervalYear +IntervalDay +UUID +Decimal +PrecisionTimestamp +PrecisionTimestampTZ +FixedChar +VarChar +FixedBinary +Struct +NStruct +List +Map +ANY +UserDefined +Bool +Str +VBin +Ts +TsTZ +IYear +IDay +Dec +PTs +PTsTZ +FChar +VChar +FBin +DOUBLE_COLON +IDENTIFIER +O_ANGLE_BRACKET +C_ANGLE_BRACKET +OPAREN +CPAREN +OBRACKET +CBRACKET +COMMA +EQ +COLON +QMARK +HASH +DOT + +rule names: +SUBSTRAIT_SCALAR_TEST +FORMAT_VERSION +SUBSTRAIT_INCLUDE +DESCRIPTION_LINE +ERROR_RESULT +UNDEFINED_RESULT +OVERFLOW +ROUNDING +ERROR +SATURATE +SILENT +TIE_TO_EVEN +NAN +INTEGER_LITERAL +DECIMAL_LITERAL +FLOAT_LITERAL +BOOLEAN_LITERAL +FourDigits +TwoDigits +TIMESTAMP_TZ_LITERAL +TIMESTAMP_LITERAL +TIME_LITERAL +DATE_LITERAL +PERIOD_PREFIX +TIME_PREFIX +YEAR_SUFFIX +M_SUFFIX +DAY_SUFFIX +HOUR_SUFFIX +SECOND_SUFFIX +FRACTIONAL_SECOND_SUFFIX +INTERVAL_YEAR_LITERAL +INTERVAL_DAY_LITERAL +TIME_INTERVAL +NULL_LITERAL +STRING_LITERAL +LineComment +BlockComment +Whitespace +A +B +C +D +E +F +G +H +I +J +K +L +M +N +O +P +Q +R +S +T +U +V +W +X +Y +Z +DIGIT +INTEGER +If +Then +Else +Boolean +I8 +I16 +I32 +I64 +FP32 +FP64 +String +Binary +Timestamp +TimestampTZ +Date +Time +IntervalYear +IntervalDay +UUID +Decimal +PrecisionTimestamp +PrecisionTimestampTZ +FixedChar +VarChar +FixedBinary +Struct +NStruct +List +Map +ANY +UserDefined +Bool +Str +VBin +Ts +TsTZ +IYear +IDay +Dec +PTs +PTsTZ +FChar +VChar +FBin +DOUBLE_COLON +IDENTIFIER +O_ANGLE_BRACKET +C_ANGLE_BRACKET +OPAREN +CPAREN +OBRACKET +CBRACKET +COMMA +EQ +COLON +QMARK +HASH +DOT + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 94, 1118, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 4, 1, 281, 8, 1, 11, 1, 12, 1, 282, 1, 1, 1, 1, 4, 1, 287, 8, 1, 11, 1, 12, 1, 288, 3, 1, 291, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 320, 8, 3, 10, 3, 12, 3, 323, 9, 3, 1, 3, 3, 3, 326, 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 3, 13, 409, 8, 13, 1, 13, 1, 13, 1, 14, 3, 14, 414, 8, 14, 1, 14, 4, 14, 417, 8, 14, 11, 14, 12, 14, 418, 1, 14, 1, 14, 4, 14, 423, 8, 14, 11, 14, 12, 14, 424, 3, 14, 427, 8, 14, 1, 15, 3, 15, 430, 8, 15, 1, 15, 4, 15, 433, 8, 15, 11, 15, 12, 15, 434, 1, 15, 1, 15, 5, 15, 439, 8, 15, 10, 15, 12, 15, 442, 9, 15, 3, 15, 444, 8, 15, 1, 15, 1, 15, 3, 15, 448, 8, 15, 1, 15, 4, 15, 451, 8, 15, 11, 15, 12, 15, 452, 3, 15, 455, 8, 15, 1, 15, 3, 15, 458, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 473, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 484, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 4, 19, 508, 8, 19, 11, 19, 12, 19, 509, 3, 19, 512, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 4, 20, 534, 8, 20, 11, 20, 12, 20, 535, 3, 20, 538, 8, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 4, 21, 550, 8, 21, 11, 21, 12, 21, 551, 3, 21, 554, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 589, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 599, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 608, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 618, 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 625, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 630, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 635, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 642, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 647, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 654, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 659, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 5, 35, 672, 8, 35, 10, 35, 12, 35, 675, 9, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 683, 8, 36, 10, 36, 12, 36, 686, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 4, 37, 695, 8, 37, 11, 37, 12, 37, 696, 1, 37, 3, 37, 700, 8, 37, 1, 37, 5, 37, 703, 8, 37, 10, 37, 12, 37, 706, 9, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 4, 38, 714, 8, 38, 11, 38, 12, 38, 715, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 64, 1, 64, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 5, 66, 777, 8, 66, 10, 66, 12, 66, 780, 9, 66, 3, 66, 782, 8, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 5, 112, 1090, 8, 112, 10, 112, 12, 112, 1093, 9, 112, 1, 113, 1, 113, 1, 114, 1, 114, 1, 115, 1, 115, 1, 116, 1, 116, 1, 117, 1, 117, 1, 118, 1, 118, 1, 119, 1, 119, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 1, 124, 1, 124, 0, 0, 125, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 0, 37, 0, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 30, 65, 31, 67, 0, 69, 32, 71, 33, 73, 34, 75, 35, 77, 36, 79, 0, 81, 0, 83, 0, 85, 0, 87, 0, 89, 0, 91, 0, 93, 0, 95, 0, 97, 0, 99, 0, 101, 0, 103, 0, 105, 0, 107, 0, 109, 0, 111, 0, 113, 0, 115, 0, 117, 0, 119, 0, 121, 0, 123, 0, 125, 0, 127, 0, 129, 0, 131, 0, 133, 0, 135, 37, 137, 38, 139, 39, 141, 40, 143, 41, 145, 42, 147, 43, 149, 44, 151, 45, 153, 46, 155, 47, 157, 48, 159, 49, 161, 50, 163, 51, 165, 52, 167, 53, 169, 54, 171, 55, 173, 56, 175, 57, 177, 58, 179, 59, 181, 60, 183, 61, 185, 62, 187, 63, 189, 64, 191, 65, 193, 66, 195, 67, 197, 68, 199, 69, 201, 70, 203, 71, 205, 72, 207, 73, 209, 74, 211, 75, 213, 76, 215, 77, 217, 78, 219, 79, 221, 80, 223, 81, 225, 82, 227, 83, 229, 84, 231, 85, 233, 86, 235, 87, 237, 88, 239, 89, 241, 90, 243, 91, 245, 92, 247, 93, 249, 94, 1, 0, 36, 2, 0, 10, 10, 13, 13, 2, 0, 43, 43, 45, 45, 1, 0, 48, 57, 2, 0, 69, 69, 101, 101, 2, 0, 39, 39, 92, 92, 1, 0, 42, 42, 2, 0, 42, 42, 47, 47, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 1, 0, 49, 57, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1139, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 1, 251, 1, 0, 0, 0, 3, 278, 1, 0, 0, 0, 5, 292, 1, 0, 0, 0, 7, 315, 1, 0, 0, 0, 9, 329, 1, 0, 0, 0, 11, 338, 1, 0, 0, 0, 13, 351, 1, 0, 0, 0, 15, 360, 1, 0, 0, 0, 17, 369, 1, 0, 0, 0, 19, 375, 1, 0, 0, 0, 21, 384, 1, 0, 0, 0, 23, 391, 1, 0, 0, 0, 25, 403, 1, 0, 0, 0, 27, 408, 1, 0, 0, 0, 29, 413, 1, 0, 0, 0, 31, 472, 1, 0, 0, 0, 33, 483, 1, 0, 0, 0, 35, 485, 1, 0, 0, 0, 37, 490, 1, 0, 0, 0, 39, 493, 1, 0, 0, 0, 41, 519, 1, 0, 0, 0, 43, 541, 1, 0, 0, 0, 45, 557, 1, 0, 0, 0, 47, 565, 1, 0, 0, 0, 49, 567, 1, 0, 0, 0, 51, 569, 1, 0, 0, 0, 53, 571, 1, 0, 0, 0, 55, 573, 1, 0, 0, 0, 57, 575, 1, 0, 0, 0, 59, 577, 1, 0, 0, 0, 61, 579, 1, 0, 0, 0, 63, 598, 1, 0, 0, 0, 65, 617, 1, 0, 0, 0, 67, 658, 1, 0, 0, 0, 69, 660, 1, 0, 0, 0, 71, 665, 1, 0, 0, 0, 73, 678, 1, 0, 0, 0, 75, 689, 1, 0, 0, 0, 77, 713, 1, 0, 0, 0, 79, 719, 1, 0, 0, 0, 81, 721, 1, 0, 0, 0, 83, 723, 1, 0, 0, 0, 85, 725, 1, 0, 0, 0, 87, 727, 1, 0, 0, 0, 89, 729, 1, 0, 0, 0, 91, 731, 1, 0, 0, 0, 93, 733, 1, 0, 0, 0, 95, 735, 1, 0, 0, 0, 97, 737, 1, 0, 0, 0, 99, 739, 1, 0, 0, 0, 101, 741, 1, 0, 0, 0, 103, 743, 1, 0, 0, 0, 105, 745, 1, 0, 0, 0, 107, 747, 1, 0, 0, 0, 109, 749, 1, 0, 0, 0, 111, 751, 1, 0, 0, 0, 113, 753, 1, 0, 0, 0, 115, 755, 1, 0, 0, 0, 117, 757, 1, 0, 0, 0, 119, 759, 1, 0, 0, 0, 121, 761, 1, 0, 0, 0, 123, 763, 1, 0, 0, 0, 125, 765, 1, 0, 0, 0, 127, 767, 1, 0, 0, 0, 129, 769, 1, 0, 0, 0, 131, 771, 1, 0, 0, 0, 133, 781, 1, 0, 0, 0, 135, 783, 1, 0, 0, 0, 137, 786, 1, 0, 0, 0, 139, 791, 1, 0, 0, 0, 141, 796, 1, 0, 0, 0, 143, 804, 1, 0, 0, 0, 145, 807, 1, 0, 0, 0, 147, 811, 1, 0, 0, 0, 149, 815, 1, 0, 0, 0, 151, 819, 1, 0, 0, 0, 153, 824, 1, 0, 0, 0, 155, 829, 1, 0, 0, 0, 157, 836, 1, 0, 0, 0, 159, 843, 1, 0, 0, 0, 161, 853, 1, 0, 0, 0, 163, 866, 1, 0, 0, 0, 165, 871, 1, 0, 0, 0, 167, 876, 1, 0, 0, 0, 169, 890, 1, 0, 0, 0, 171, 903, 1, 0, 0, 0, 173, 908, 1, 0, 0, 0, 175, 916, 1, 0, 0, 0, 177, 936, 1, 0, 0, 0, 179, 959, 1, 0, 0, 0, 181, 969, 1, 0, 0, 0, 183, 977, 1, 0, 0, 0, 185, 989, 1, 0, 0, 0, 187, 996, 1, 0, 0, 0, 189, 1004, 1, 0, 0, 0, 191, 1009, 1, 0, 0, 0, 193, 1013, 1, 0, 0, 0, 195, 1017, 1, 0, 0, 0, 197, 1020, 1, 0, 0, 0, 199, 1025, 1, 0, 0, 0, 201, 1029, 1, 0, 0, 0, 203, 1034, 1, 0, 0, 0, 205, 1037, 1, 0, 0, 0, 207, 1042, 1, 0, 0, 0, 209, 1048, 1, 0, 0, 0, 211, 1053, 1, 0, 0, 0, 213, 1057, 1, 0, 0, 0, 215, 1061, 1, 0, 0, 0, 217, 1067, 1, 0, 0, 0, 219, 1073, 1, 0, 0, 0, 221, 1079, 1, 0, 0, 0, 223, 1084, 1, 0, 0, 0, 225, 1087, 1, 0, 0, 0, 227, 1094, 1, 0, 0, 0, 229, 1096, 1, 0, 0, 0, 231, 1098, 1, 0, 0, 0, 233, 1100, 1, 0, 0, 0, 235, 1102, 1, 0, 0, 0, 237, 1104, 1, 0, 0, 0, 239, 1106, 1, 0, 0, 0, 241, 1108, 1, 0, 0, 0, 243, 1110, 1, 0, 0, 0, 245, 1112, 1, 0, 0, 0, 247, 1114, 1, 0, 0, 0, 249, 1116, 1, 0, 0, 0, 251, 252, 5, 35, 0, 0, 252, 253, 5, 35, 0, 0, 253, 254, 5, 35, 0, 0, 254, 255, 5, 32, 0, 0, 255, 256, 5, 83, 0, 0, 256, 257, 5, 85, 0, 0, 257, 258, 5, 66, 0, 0, 258, 259, 5, 83, 0, 0, 259, 260, 5, 84, 0, 0, 260, 261, 5, 82, 0, 0, 261, 262, 5, 65, 0, 0, 262, 263, 5, 73, 0, 0, 263, 264, 5, 84, 0, 0, 264, 265, 5, 95, 0, 0, 265, 266, 5, 83, 0, 0, 266, 267, 5, 67, 0, 0, 267, 268, 5, 65, 0, 0, 268, 269, 5, 76, 0, 0, 269, 270, 5, 65, 0, 0, 270, 271, 5, 82, 0, 0, 271, 272, 5, 95, 0, 0, 272, 273, 5, 84, 0, 0, 273, 274, 5, 69, 0, 0, 274, 275, 5, 83, 0, 0, 275, 276, 5, 84, 0, 0, 276, 277, 5, 58, 0, 0, 277, 2, 1, 0, 0, 0, 278, 280, 5, 118, 0, 0, 279, 281, 3, 131, 65, 0, 280, 279, 1, 0, 0, 0, 281, 282, 1, 0, 0, 0, 282, 280, 1, 0, 0, 0, 282, 283, 1, 0, 0, 0, 283, 290, 1, 0, 0, 0, 284, 286, 5, 46, 0, 0, 285, 287, 3, 131, 65, 0, 286, 285, 1, 0, 0, 0, 287, 288, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 288, 289, 1, 0, 0, 0, 289, 291, 1, 0, 0, 0, 290, 284, 1, 0, 0, 0, 290, 291, 1, 0, 0, 0, 291, 4, 1, 0, 0, 0, 292, 293, 5, 35, 0, 0, 293, 294, 5, 35, 0, 0, 294, 295, 5, 35, 0, 0, 295, 296, 5, 32, 0, 0, 296, 297, 5, 83, 0, 0, 297, 298, 5, 85, 0, 0, 298, 299, 5, 66, 0, 0, 299, 300, 5, 83, 0, 0, 300, 301, 5, 84, 0, 0, 301, 302, 5, 82, 0, 0, 302, 303, 5, 65, 0, 0, 303, 304, 5, 73, 0, 0, 304, 305, 5, 84, 0, 0, 305, 306, 5, 95, 0, 0, 306, 307, 5, 73, 0, 0, 307, 308, 5, 78, 0, 0, 308, 309, 5, 67, 0, 0, 309, 310, 5, 76, 0, 0, 310, 311, 5, 85, 0, 0, 311, 312, 5, 68, 0, 0, 312, 313, 5, 69, 0, 0, 313, 314, 5, 58, 0, 0, 314, 6, 1, 0, 0, 0, 315, 316, 5, 35, 0, 0, 316, 317, 5, 32, 0, 0, 317, 321, 1, 0, 0, 0, 318, 320, 8, 0, 0, 0, 319, 318, 1, 0, 0, 0, 320, 323, 1, 0, 0, 0, 321, 319, 1, 0, 0, 0, 321, 322, 1, 0, 0, 0, 322, 325, 1, 0, 0, 0, 323, 321, 1, 0, 0, 0, 324, 326, 5, 13, 0, 0, 325, 324, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 327, 1, 0, 0, 0, 327, 328, 5, 10, 0, 0, 328, 8, 1, 0, 0, 0, 329, 330, 5, 60, 0, 0, 330, 331, 5, 33, 0, 0, 331, 332, 5, 69, 0, 0, 332, 333, 5, 82, 0, 0, 333, 334, 5, 82, 0, 0, 334, 335, 5, 79, 0, 0, 335, 336, 5, 82, 0, 0, 336, 337, 5, 62, 0, 0, 337, 10, 1, 0, 0, 0, 338, 339, 5, 60, 0, 0, 339, 340, 5, 33, 0, 0, 340, 341, 5, 85, 0, 0, 341, 342, 5, 78, 0, 0, 342, 343, 5, 68, 0, 0, 343, 344, 5, 69, 0, 0, 344, 345, 5, 70, 0, 0, 345, 346, 5, 73, 0, 0, 346, 347, 5, 78, 0, 0, 347, 348, 5, 69, 0, 0, 348, 349, 5, 68, 0, 0, 349, 350, 5, 62, 0, 0, 350, 12, 1, 0, 0, 0, 351, 352, 5, 111, 0, 0, 352, 353, 5, 118, 0, 0, 353, 354, 5, 101, 0, 0, 354, 355, 5, 114, 0, 0, 355, 356, 5, 108, 0, 0, 356, 357, 5, 102, 0, 0, 357, 358, 5, 111, 0, 0, 358, 359, 5, 119, 0, 0, 359, 14, 1, 0, 0, 0, 360, 361, 5, 114, 0, 0, 361, 362, 5, 111, 0, 0, 362, 363, 5, 117, 0, 0, 363, 364, 5, 110, 0, 0, 364, 365, 5, 100, 0, 0, 365, 366, 5, 105, 0, 0, 366, 367, 5, 110, 0, 0, 367, 368, 5, 103, 0, 0, 368, 16, 1, 0, 0, 0, 369, 370, 5, 69, 0, 0, 370, 371, 5, 82, 0, 0, 371, 372, 5, 82, 0, 0, 372, 373, 5, 79, 0, 0, 373, 374, 5, 82, 0, 0, 374, 18, 1, 0, 0, 0, 375, 376, 5, 83, 0, 0, 376, 377, 5, 65, 0, 0, 377, 378, 5, 84, 0, 0, 378, 379, 5, 85, 0, 0, 379, 380, 5, 82, 0, 0, 380, 381, 5, 65, 0, 0, 381, 382, 5, 84, 0, 0, 382, 383, 5, 69, 0, 0, 383, 20, 1, 0, 0, 0, 384, 385, 5, 83, 0, 0, 385, 386, 5, 73, 0, 0, 386, 387, 5, 76, 0, 0, 387, 388, 5, 69, 0, 0, 388, 389, 5, 78, 0, 0, 389, 390, 5, 84, 0, 0, 390, 22, 1, 0, 0, 0, 391, 392, 5, 84, 0, 0, 392, 393, 5, 73, 0, 0, 393, 394, 5, 69, 0, 0, 394, 395, 5, 95, 0, 0, 395, 396, 5, 84, 0, 0, 396, 397, 5, 79, 0, 0, 397, 398, 5, 95, 0, 0, 398, 399, 5, 69, 0, 0, 399, 400, 5, 86, 0, 0, 400, 401, 5, 69, 0, 0, 401, 402, 5, 78, 0, 0, 402, 24, 1, 0, 0, 0, 403, 404, 5, 78, 0, 0, 404, 405, 5, 65, 0, 0, 405, 406, 5, 78, 0, 0, 406, 26, 1, 0, 0, 0, 407, 409, 7, 1, 0, 0, 408, 407, 1, 0, 0, 0, 408, 409, 1, 0, 0, 0, 409, 410, 1, 0, 0, 0, 410, 411, 3, 133, 66, 0, 411, 28, 1, 0, 0, 0, 412, 414, 7, 1, 0, 0, 413, 412, 1, 0, 0, 0, 413, 414, 1, 0, 0, 0, 414, 416, 1, 0, 0, 0, 415, 417, 7, 2, 0, 0, 416, 415, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 416, 1, 0, 0, 0, 418, 419, 1, 0, 0, 0, 419, 426, 1, 0, 0, 0, 420, 422, 5, 46, 0, 0, 421, 423, 7, 2, 0, 0, 422, 421, 1, 0, 0, 0, 423, 424, 1, 0, 0, 0, 424, 422, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 427, 1, 0, 0, 0, 426, 420, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 30, 1, 0, 0, 0, 428, 430, 7, 1, 0, 0, 429, 428, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430, 432, 1, 0, 0, 0, 431, 433, 7, 2, 0, 0, 432, 431, 1, 0, 0, 0, 433, 434, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 435, 1, 0, 0, 0, 435, 443, 1, 0, 0, 0, 436, 440, 5, 46, 0, 0, 437, 439, 7, 2, 0, 0, 438, 437, 1, 0, 0, 0, 439, 442, 1, 0, 0, 0, 440, 438, 1, 0, 0, 0, 440, 441, 1, 0, 0, 0, 441, 444, 1, 0, 0, 0, 442, 440, 1, 0, 0, 0, 443, 436, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 454, 1, 0, 0, 0, 445, 447, 7, 3, 0, 0, 446, 448, 7, 1, 0, 0, 447, 446, 1, 0, 0, 0, 447, 448, 1, 0, 0, 0, 448, 450, 1, 0, 0, 0, 449, 451, 7, 2, 0, 0, 450, 449, 1, 0, 0, 0, 451, 452, 1, 0, 0, 0, 452, 450, 1, 0, 0, 0, 452, 453, 1, 0, 0, 0, 453, 455, 1, 0, 0, 0, 454, 445, 1, 0, 0, 0, 454, 455, 1, 0, 0, 0, 455, 473, 1, 0, 0, 0, 456, 458, 7, 1, 0, 0, 457, 456, 1, 0, 0, 0, 457, 458, 1, 0, 0, 0, 458, 459, 1, 0, 0, 0, 459, 460, 5, 105, 0, 0, 460, 461, 5, 110, 0, 0, 461, 473, 5, 102, 0, 0, 462, 463, 5, 110, 0, 0, 463, 464, 5, 97, 0, 0, 464, 473, 5, 110, 0, 0, 465, 466, 5, 78, 0, 0, 466, 467, 5, 97, 0, 0, 467, 473, 5, 78, 0, 0, 468, 469, 5, 115, 0, 0, 469, 470, 5, 110, 0, 0, 470, 471, 5, 97, 0, 0, 471, 473, 5, 110, 0, 0, 472, 429, 1, 0, 0, 0, 472, 457, 1, 0, 0, 0, 472, 462, 1, 0, 0, 0, 472, 465, 1, 0, 0, 0, 472, 468, 1, 0, 0, 0, 473, 32, 1, 0, 0, 0, 474, 475, 5, 116, 0, 0, 475, 476, 5, 114, 0, 0, 476, 477, 5, 117, 0, 0, 477, 484, 5, 101, 0, 0, 478, 479, 5, 102, 0, 0, 479, 480, 5, 97, 0, 0, 480, 481, 5, 108, 0, 0, 481, 482, 5, 115, 0, 0, 482, 484, 5, 101, 0, 0, 483, 474, 1, 0, 0, 0, 483, 478, 1, 0, 0, 0, 484, 34, 1, 0, 0, 0, 485, 486, 7, 2, 0, 0, 486, 487, 7, 2, 0, 0, 487, 488, 7, 2, 0, 0, 488, 489, 7, 2, 0, 0, 489, 36, 1, 0, 0, 0, 490, 491, 7, 2, 0, 0, 491, 492, 7, 2, 0, 0, 492, 38, 1, 0, 0, 0, 493, 494, 5, 39, 0, 0, 494, 495, 3, 35, 17, 0, 495, 496, 5, 45, 0, 0, 496, 497, 3, 37, 18, 0, 497, 498, 5, 45, 0, 0, 498, 499, 3, 37, 18, 0, 499, 500, 5, 84, 0, 0, 500, 501, 3, 37, 18, 0, 501, 502, 5, 58, 0, 0, 502, 503, 3, 37, 18, 0, 503, 504, 5, 58, 0, 0, 504, 511, 3, 37, 18, 0, 505, 507, 5, 46, 0, 0, 506, 508, 7, 2, 0, 0, 507, 506, 1, 0, 0, 0, 508, 509, 1, 0, 0, 0, 509, 507, 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, 512, 1, 0, 0, 0, 511, 505, 1, 0, 0, 0, 511, 512, 1, 0, 0, 0, 512, 513, 1, 0, 0, 0, 513, 514, 7, 1, 0, 0, 514, 515, 3, 37, 18, 0, 515, 516, 5, 58, 0, 0, 516, 517, 3, 37, 18, 0, 517, 518, 5, 39, 0, 0, 518, 40, 1, 0, 0, 0, 519, 520, 5, 39, 0, 0, 520, 521, 3, 35, 17, 0, 521, 522, 5, 45, 0, 0, 522, 523, 3, 37, 18, 0, 523, 524, 5, 45, 0, 0, 524, 525, 3, 37, 18, 0, 525, 526, 5, 84, 0, 0, 526, 527, 3, 37, 18, 0, 527, 528, 5, 58, 0, 0, 528, 529, 3, 37, 18, 0, 529, 530, 5, 58, 0, 0, 530, 537, 3, 37, 18, 0, 531, 533, 5, 46, 0, 0, 532, 534, 7, 2, 0, 0, 533, 532, 1, 0, 0, 0, 534, 535, 1, 0, 0, 0, 535, 533, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 538, 1, 0, 0, 0, 537, 531, 1, 0, 0, 0, 537, 538, 1, 0, 0, 0, 538, 539, 1, 0, 0, 0, 539, 540, 5, 39, 0, 0, 540, 42, 1, 0, 0, 0, 541, 542, 5, 39, 0, 0, 542, 543, 3, 37, 18, 0, 543, 544, 5, 58, 0, 0, 544, 545, 3, 37, 18, 0, 545, 546, 5, 58, 0, 0, 546, 553, 3, 37, 18, 0, 547, 549, 5, 46, 0, 0, 548, 550, 7, 2, 0, 0, 549, 548, 1, 0, 0, 0, 550, 551, 1, 0, 0, 0, 551, 549, 1, 0, 0, 0, 551, 552, 1, 0, 0, 0, 552, 554, 1, 0, 0, 0, 553, 547, 1, 0, 0, 0, 553, 554, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 556, 5, 39, 0, 0, 556, 44, 1, 0, 0, 0, 557, 558, 5, 39, 0, 0, 558, 559, 3, 35, 17, 0, 559, 560, 5, 45, 0, 0, 560, 561, 3, 37, 18, 0, 561, 562, 5, 45, 0, 0, 562, 563, 3, 37, 18, 0, 563, 564, 5, 39, 0, 0, 564, 46, 1, 0, 0, 0, 565, 566, 5, 80, 0, 0, 566, 48, 1, 0, 0, 0, 567, 568, 5, 84, 0, 0, 568, 50, 1, 0, 0, 0, 569, 570, 5, 89, 0, 0, 570, 52, 1, 0, 0, 0, 571, 572, 5, 77, 0, 0, 572, 54, 1, 0, 0, 0, 573, 574, 5, 68, 0, 0, 574, 56, 1, 0, 0, 0, 575, 576, 5, 72, 0, 0, 576, 58, 1, 0, 0, 0, 577, 578, 5, 83, 0, 0, 578, 60, 1, 0, 0, 0, 579, 580, 5, 70, 0, 0, 580, 62, 1, 0, 0, 0, 581, 582, 5, 39, 0, 0, 582, 583, 3, 47, 23, 0, 583, 584, 3, 27, 13, 0, 584, 588, 3, 51, 25, 0, 585, 586, 3, 27, 13, 0, 586, 587, 3, 53, 26, 0, 587, 589, 1, 0, 0, 0, 588, 585, 1, 0, 0, 0, 588, 589, 1, 0, 0, 0, 589, 590, 1, 0, 0, 0, 590, 591, 5, 39, 0, 0, 591, 599, 1, 0, 0, 0, 592, 593, 5, 39, 0, 0, 593, 594, 3, 47, 23, 0, 594, 595, 3, 27, 13, 0, 595, 596, 3, 53, 26, 0, 596, 597, 5, 39, 0, 0, 597, 599, 1, 0, 0, 0, 598, 581, 1, 0, 0, 0, 598, 592, 1, 0, 0, 0, 599, 64, 1, 0, 0, 0, 600, 601, 5, 39, 0, 0, 601, 602, 3, 47, 23, 0, 602, 603, 3, 27, 13, 0, 603, 607, 3, 55, 27, 0, 604, 605, 3, 49, 24, 0, 605, 606, 3, 67, 33, 0, 606, 608, 1, 0, 0, 0, 607, 604, 1, 0, 0, 0, 607, 608, 1, 0, 0, 0, 608, 609, 1, 0, 0, 0, 609, 610, 5, 39, 0, 0, 610, 618, 1, 0, 0, 0, 611, 612, 5, 39, 0, 0, 612, 613, 3, 47, 23, 0, 613, 614, 3, 49, 24, 0, 614, 615, 3, 67, 33, 0, 615, 616, 5, 39, 0, 0, 616, 618, 1, 0, 0, 0, 617, 600, 1, 0, 0, 0, 617, 611, 1, 0, 0, 0, 618, 66, 1, 0, 0, 0, 619, 620, 3, 27, 13, 0, 620, 624, 3, 57, 28, 0, 621, 622, 3, 27, 13, 0, 622, 623, 3, 53, 26, 0, 623, 625, 1, 0, 0, 0, 624, 621, 1, 0, 0, 0, 624, 625, 1, 0, 0, 0, 625, 629, 1, 0, 0, 0, 626, 627, 3, 27, 13, 0, 627, 628, 3, 59, 29, 0, 628, 630, 1, 0, 0, 0, 629, 626, 1, 0, 0, 0, 629, 630, 1, 0, 0, 0, 630, 634, 1, 0, 0, 0, 631, 632, 3, 27, 13, 0, 632, 633, 3, 61, 30, 0, 633, 635, 1, 0, 0, 0, 634, 631, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 659, 1, 0, 0, 0, 636, 637, 3, 27, 13, 0, 637, 641, 3, 53, 26, 0, 638, 639, 3, 27, 13, 0, 639, 640, 3, 59, 29, 0, 640, 642, 1, 0, 0, 0, 641, 638, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 646, 1, 0, 0, 0, 643, 644, 3, 27, 13, 0, 644, 645, 3, 61, 30, 0, 645, 647, 1, 0, 0, 0, 646, 643, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 659, 1, 0, 0, 0, 648, 649, 3, 27, 13, 0, 649, 653, 3, 59, 29, 0, 650, 651, 3, 27, 13, 0, 651, 652, 3, 61, 30, 0, 652, 654, 1, 0, 0, 0, 653, 650, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 659, 1, 0, 0, 0, 655, 656, 3, 27, 13, 0, 656, 657, 3, 61, 30, 0, 657, 659, 1, 0, 0, 0, 658, 619, 1, 0, 0, 0, 658, 636, 1, 0, 0, 0, 658, 648, 1, 0, 0, 0, 658, 655, 1, 0, 0, 0, 659, 68, 1, 0, 0, 0, 660, 661, 5, 110, 0, 0, 661, 662, 5, 117, 0, 0, 662, 663, 5, 108, 0, 0, 663, 664, 5, 108, 0, 0, 664, 70, 1, 0, 0, 0, 665, 673, 5, 39, 0, 0, 666, 667, 5, 92, 0, 0, 667, 672, 9, 0, 0, 0, 668, 669, 5, 39, 0, 0, 669, 672, 5, 39, 0, 0, 670, 672, 8, 4, 0, 0, 671, 666, 1, 0, 0, 0, 671, 668, 1, 0, 0, 0, 671, 670, 1, 0, 0, 0, 672, 675, 1, 0, 0, 0, 673, 671, 1, 0, 0, 0, 673, 674, 1, 0, 0, 0, 674, 676, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 676, 677, 5, 39, 0, 0, 677, 72, 1, 0, 0, 0, 678, 679, 5, 47, 0, 0, 679, 680, 5, 47, 0, 0, 680, 684, 1, 0, 0, 0, 681, 683, 8, 0, 0, 0, 682, 681, 1, 0, 0, 0, 683, 686, 1, 0, 0, 0, 684, 682, 1, 0, 0, 0, 684, 685, 1, 0, 0, 0, 685, 687, 1, 0, 0, 0, 686, 684, 1, 0, 0, 0, 687, 688, 6, 36, 0, 0, 688, 74, 1, 0, 0, 0, 689, 690, 5, 47, 0, 0, 690, 691, 5, 42, 0, 0, 691, 699, 1, 0, 0, 0, 692, 700, 8, 5, 0, 0, 693, 695, 5, 42, 0, 0, 694, 693, 1, 0, 0, 0, 695, 696, 1, 0, 0, 0, 696, 694, 1, 0, 0, 0, 696, 697, 1, 0, 0, 0, 697, 698, 1, 0, 0, 0, 698, 700, 8, 6, 0, 0, 699, 692, 1, 0, 0, 0, 699, 694, 1, 0, 0, 0, 700, 704, 1, 0, 0, 0, 701, 703, 5, 42, 0, 0, 702, 701, 1, 0, 0, 0, 703, 706, 1, 0, 0, 0, 704, 702, 1, 0, 0, 0, 704, 705, 1, 0, 0, 0, 705, 707, 1, 0, 0, 0, 706, 704, 1, 0, 0, 0, 707, 708, 5, 42, 0, 0, 708, 709, 5, 47, 0, 0, 709, 710, 1, 0, 0, 0, 710, 711, 6, 37, 0, 0, 711, 76, 1, 0, 0, 0, 712, 714, 7, 7, 0, 0, 713, 712, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 718, 6, 38, 0, 0, 718, 78, 1, 0, 0, 0, 719, 720, 7, 8, 0, 0, 720, 80, 1, 0, 0, 0, 721, 722, 7, 9, 0, 0, 722, 82, 1, 0, 0, 0, 723, 724, 7, 10, 0, 0, 724, 84, 1, 0, 0, 0, 725, 726, 7, 11, 0, 0, 726, 86, 1, 0, 0, 0, 727, 728, 7, 3, 0, 0, 728, 88, 1, 0, 0, 0, 729, 730, 7, 12, 0, 0, 730, 90, 1, 0, 0, 0, 731, 732, 7, 13, 0, 0, 732, 92, 1, 0, 0, 0, 733, 734, 7, 14, 0, 0, 734, 94, 1, 0, 0, 0, 735, 736, 7, 15, 0, 0, 736, 96, 1, 0, 0, 0, 737, 738, 7, 16, 0, 0, 738, 98, 1, 0, 0, 0, 739, 740, 7, 17, 0, 0, 740, 100, 1, 0, 0, 0, 741, 742, 7, 18, 0, 0, 742, 102, 1, 0, 0, 0, 743, 744, 7, 19, 0, 0, 744, 104, 1, 0, 0, 0, 745, 746, 7, 20, 0, 0, 746, 106, 1, 0, 0, 0, 747, 748, 7, 21, 0, 0, 748, 108, 1, 0, 0, 0, 749, 750, 7, 22, 0, 0, 750, 110, 1, 0, 0, 0, 751, 752, 7, 23, 0, 0, 752, 112, 1, 0, 0, 0, 753, 754, 7, 24, 0, 0, 754, 114, 1, 0, 0, 0, 755, 756, 7, 25, 0, 0, 756, 116, 1, 0, 0, 0, 757, 758, 7, 26, 0, 0, 758, 118, 1, 0, 0, 0, 759, 760, 7, 27, 0, 0, 760, 120, 1, 0, 0, 0, 761, 762, 7, 28, 0, 0, 762, 122, 1, 0, 0, 0, 763, 764, 7, 29, 0, 0, 764, 124, 1, 0, 0, 0, 765, 766, 7, 30, 0, 0, 766, 126, 1, 0, 0, 0, 767, 768, 7, 31, 0, 0, 768, 128, 1, 0, 0, 0, 769, 770, 7, 32, 0, 0, 770, 130, 1, 0, 0, 0, 771, 772, 7, 2, 0, 0, 772, 132, 1, 0, 0, 0, 773, 782, 5, 48, 0, 0, 774, 778, 7, 33, 0, 0, 775, 777, 7, 2, 0, 0, 776, 775, 1, 0, 0, 0, 777, 780, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 778, 779, 1, 0, 0, 0, 779, 782, 1, 0, 0, 0, 780, 778, 1, 0, 0, 0, 781, 773, 1, 0, 0, 0, 781, 774, 1, 0, 0, 0, 782, 134, 1, 0, 0, 0, 783, 784, 3, 95, 47, 0, 784, 785, 3, 89, 44, 0, 785, 136, 1, 0, 0, 0, 786, 787, 3, 117, 58, 0, 787, 788, 3, 93, 46, 0, 788, 789, 3, 87, 43, 0, 789, 790, 3, 105, 52, 0, 790, 138, 1, 0, 0, 0, 791, 792, 3, 87, 43, 0, 792, 793, 3, 101, 50, 0, 793, 794, 3, 115, 57, 0, 794, 795, 3, 87, 43, 0, 795, 140, 1, 0, 0, 0, 796, 797, 3, 81, 40, 0, 797, 798, 3, 107, 53, 0, 798, 799, 3, 107, 53, 0, 799, 800, 3, 101, 50, 0, 800, 801, 3, 87, 43, 0, 801, 802, 3, 79, 39, 0, 802, 803, 3, 105, 52, 0, 803, 142, 1, 0, 0, 0, 804, 805, 3, 95, 47, 0, 805, 806, 5, 56, 0, 0, 806, 144, 1, 0, 0, 0, 807, 808, 3, 95, 47, 0, 808, 809, 5, 49, 0, 0, 809, 810, 5, 54, 0, 0, 810, 146, 1, 0, 0, 0, 811, 812, 3, 95, 47, 0, 812, 813, 5, 51, 0, 0, 813, 814, 5, 50, 0, 0, 814, 148, 1, 0, 0, 0, 815, 816, 3, 95, 47, 0, 816, 817, 5, 54, 0, 0, 817, 818, 5, 52, 0, 0, 818, 150, 1, 0, 0, 0, 819, 820, 3, 89, 44, 0, 820, 821, 3, 109, 54, 0, 821, 822, 5, 51, 0, 0, 822, 823, 5, 50, 0, 0, 823, 152, 1, 0, 0, 0, 824, 825, 3, 89, 44, 0, 825, 826, 3, 109, 54, 0, 826, 827, 5, 54, 0, 0, 827, 828, 5, 52, 0, 0, 828, 154, 1, 0, 0, 0, 829, 830, 3, 115, 57, 0, 830, 831, 3, 117, 58, 0, 831, 832, 3, 113, 56, 0, 832, 833, 3, 95, 47, 0, 833, 834, 3, 105, 52, 0, 834, 835, 3, 91, 45, 0, 835, 156, 1, 0, 0, 0, 836, 837, 3, 81, 40, 0, 837, 838, 3, 95, 47, 0, 838, 839, 3, 105, 52, 0, 839, 840, 3, 79, 39, 0, 840, 841, 3, 113, 56, 0, 841, 842, 3, 127, 63, 0, 842, 158, 1, 0, 0, 0, 843, 844, 3, 117, 58, 0, 844, 845, 3, 95, 47, 0, 845, 846, 3, 103, 51, 0, 846, 847, 3, 87, 43, 0, 847, 848, 3, 115, 57, 0, 848, 849, 3, 117, 58, 0, 849, 850, 3, 79, 39, 0, 850, 851, 3, 103, 51, 0, 851, 852, 3, 109, 54, 0, 852, 160, 1, 0, 0, 0, 853, 854, 3, 117, 58, 0, 854, 855, 3, 95, 47, 0, 855, 856, 3, 103, 51, 0, 856, 857, 3, 87, 43, 0, 857, 858, 3, 115, 57, 0, 858, 859, 3, 117, 58, 0, 859, 860, 3, 79, 39, 0, 860, 861, 3, 103, 51, 0, 861, 862, 3, 109, 54, 0, 862, 863, 5, 95, 0, 0, 863, 864, 3, 117, 58, 0, 864, 865, 3, 129, 64, 0, 865, 162, 1, 0, 0, 0, 866, 867, 3, 85, 42, 0, 867, 868, 3, 79, 39, 0, 868, 869, 3, 117, 58, 0, 869, 870, 3, 87, 43, 0, 870, 164, 1, 0, 0, 0, 871, 872, 3, 117, 58, 0, 872, 873, 3, 95, 47, 0, 873, 874, 3, 103, 51, 0, 874, 875, 3, 87, 43, 0, 875, 166, 1, 0, 0, 0, 876, 877, 3, 95, 47, 0, 877, 878, 3, 105, 52, 0, 878, 879, 3, 117, 58, 0, 879, 880, 3, 87, 43, 0, 880, 881, 3, 113, 56, 0, 881, 882, 3, 121, 60, 0, 882, 883, 3, 79, 39, 0, 883, 884, 3, 101, 50, 0, 884, 885, 5, 95, 0, 0, 885, 886, 3, 127, 63, 0, 886, 887, 3, 87, 43, 0, 887, 888, 3, 79, 39, 0, 888, 889, 3, 113, 56, 0, 889, 168, 1, 0, 0, 0, 890, 891, 3, 95, 47, 0, 891, 892, 3, 105, 52, 0, 892, 893, 3, 117, 58, 0, 893, 894, 3, 87, 43, 0, 894, 895, 3, 113, 56, 0, 895, 896, 3, 121, 60, 0, 896, 897, 3, 79, 39, 0, 897, 898, 3, 101, 50, 0, 898, 899, 5, 95, 0, 0, 899, 900, 3, 85, 42, 0, 900, 901, 3, 79, 39, 0, 901, 902, 3, 127, 63, 0, 902, 170, 1, 0, 0, 0, 903, 904, 3, 119, 59, 0, 904, 905, 3, 119, 59, 0, 905, 906, 3, 95, 47, 0, 906, 907, 3, 85, 42, 0, 907, 172, 1, 0, 0, 0, 908, 909, 3, 85, 42, 0, 909, 910, 3, 87, 43, 0, 910, 911, 3, 83, 41, 0, 911, 912, 3, 95, 47, 0, 912, 913, 3, 103, 51, 0, 913, 914, 3, 79, 39, 0, 914, 915, 3, 101, 50, 0, 915, 174, 1, 0, 0, 0, 916, 917, 3, 109, 54, 0, 917, 918, 3, 113, 56, 0, 918, 919, 3, 87, 43, 0, 919, 920, 3, 83, 41, 0, 920, 921, 3, 95, 47, 0, 921, 922, 3, 115, 57, 0, 922, 923, 3, 95, 47, 0, 923, 924, 3, 107, 53, 0, 924, 925, 3, 105, 52, 0, 925, 926, 5, 95, 0, 0, 926, 927, 3, 117, 58, 0, 927, 928, 3, 95, 47, 0, 928, 929, 3, 103, 51, 0, 929, 930, 3, 87, 43, 0, 930, 931, 3, 115, 57, 0, 931, 932, 3, 117, 58, 0, 932, 933, 3, 79, 39, 0, 933, 934, 3, 103, 51, 0, 934, 935, 3, 109, 54, 0, 935, 176, 1, 0, 0, 0, 936, 937, 3, 109, 54, 0, 937, 938, 3, 113, 56, 0, 938, 939, 3, 87, 43, 0, 939, 940, 3, 83, 41, 0, 940, 941, 3, 95, 47, 0, 941, 942, 3, 115, 57, 0, 942, 943, 3, 95, 47, 0, 943, 944, 3, 107, 53, 0, 944, 945, 3, 105, 52, 0, 945, 946, 5, 95, 0, 0, 946, 947, 3, 117, 58, 0, 947, 948, 3, 95, 47, 0, 948, 949, 3, 103, 51, 0, 949, 950, 3, 87, 43, 0, 950, 951, 3, 115, 57, 0, 951, 952, 3, 117, 58, 0, 952, 953, 3, 79, 39, 0, 953, 954, 3, 103, 51, 0, 954, 955, 3, 109, 54, 0, 955, 956, 5, 95, 0, 0, 956, 957, 3, 117, 58, 0, 957, 958, 3, 129, 64, 0, 958, 178, 1, 0, 0, 0, 959, 960, 3, 89, 44, 0, 960, 961, 3, 95, 47, 0, 961, 962, 3, 125, 62, 0, 962, 963, 3, 87, 43, 0, 963, 964, 3, 85, 42, 0, 964, 965, 3, 83, 41, 0, 965, 966, 3, 93, 46, 0, 966, 967, 3, 79, 39, 0, 967, 968, 3, 113, 56, 0, 968, 180, 1, 0, 0, 0, 969, 970, 3, 121, 60, 0, 970, 971, 3, 79, 39, 0, 971, 972, 3, 113, 56, 0, 972, 973, 3, 83, 41, 0, 973, 974, 3, 93, 46, 0, 974, 975, 3, 79, 39, 0, 975, 976, 3, 113, 56, 0, 976, 182, 1, 0, 0, 0, 977, 978, 3, 89, 44, 0, 978, 979, 3, 95, 47, 0, 979, 980, 3, 125, 62, 0, 980, 981, 3, 87, 43, 0, 981, 982, 3, 85, 42, 0, 982, 983, 3, 81, 40, 0, 983, 984, 3, 95, 47, 0, 984, 985, 3, 105, 52, 0, 985, 986, 3, 79, 39, 0, 986, 987, 3, 113, 56, 0, 987, 988, 3, 127, 63, 0, 988, 184, 1, 0, 0, 0, 989, 990, 3, 115, 57, 0, 990, 991, 3, 117, 58, 0, 991, 992, 3, 113, 56, 0, 992, 993, 3, 119, 59, 0, 993, 994, 3, 83, 41, 0, 994, 995, 3, 117, 58, 0, 995, 186, 1, 0, 0, 0, 996, 997, 3, 105, 52, 0, 997, 998, 3, 115, 57, 0, 998, 999, 3, 117, 58, 0, 999, 1000, 3, 113, 56, 0, 1000, 1001, 3, 119, 59, 0, 1001, 1002, 3, 83, 41, 0, 1002, 1003, 3, 117, 58, 0, 1003, 188, 1, 0, 0, 0, 1004, 1005, 3, 101, 50, 0, 1005, 1006, 3, 95, 47, 0, 1006, 1007, 3, 115, 57, 0, 1007, 1008, 3, 117, 58, 0, 1008, 190, 1, 0, 0, 0, 1009, 1010, 3, 103, 51, 0, 1010, 1011, 3, 79, 39, 0, 1011, 1012, 3, 109, 54, 0, 1012, 192, 1, 0, 0, 0, 1013, 1014, 3, 79, 39, 0, 1014, 1015, 3, 105, 52, 0, 1015, 1016, 3, 127, 63, 0, 1016, 194, 1, 0, 0, 0, 1017, 1018, 3, 119, 59, 0, 1018, 1019, 5, 33, 0, 0, 1019, 196, 1, 0, 0, 0, 1020, 1021, 3, 81, 40, 0, 1021, 1022, 3, 107, 53, 0, 1022, 1023, 3, 107, 53, 0, 1023, 1024, 3, 101, 50, 0, 1024, 198, 1, 0, 0, 0, 1025, 1026, 3, 115, 57, 0, 1026, 1027, 3, 117, 58, 0, 1027, 1028, 3, 113, 56, 0, 1028, 200, 1, 0, 0, 0, 1029, 1030, 3, 121, 60, 0, 1030, 1031, 3, 81, 40, 0, 1031, 1032, 3, 95, 47, 0, 1032, 1033, 3, 105, 52, 0, 1033, 202, 1, 0, 0, 0, 1034, 1035, 3, 117, 58, 0, 1035, 1036, 3, 115, 57, 0, 1036, 204, 1, 0, 0, 0, 1037, 1038, 3, 117, 58, 0, 1038, 1039, 3, 115, 57, 0, 1039, 1040, 3, 117, 58, 0, 1040, 1041, 3, 129, 64, 0, 1041, 206, 1, 0, 0, 0, 1042, 1043, 3, 95, 47, 0, 1043, 1044, 3, 127, 63, 0, 1044, 1045, 3, 87, 43, 0, 1045, 1046, 3, 79, 39, 0, 1046, 1047, 3, 113, 56, 0, 1047, 208, 1, 0, 0, 0, 1048, 1049, 3, 95, 47, 0, 1049, 1050, 3, 85, 42, 0, 1050, 1051, 3, 79, 39, 0, 1051, 1052, 3, 127, 63, 0, 1052, 210, 1, 0, 0, 0, 1053, 1054, 3, 85, 42, 0, 1054, 1055, 3, 87, 43, 0, 1055, 1056, 3, 83, 41, 0, 1056, 212, 1, 0, 0, 0, 1057, 1058, 3, 109, 54, 0, 1058, 1059, 3, 117, 58, 0, 1059, 1060, 3, 115, 57, 0, 1060, 214, 1, 0, 0, 0, 1061, 1062, 3, 109, 54, 0, 1062, 1063, 3, 117, 58, 0, 1063, 1064, 3, 115, 57, 0, 1064, 1065, 3, 117, 58, 0, 1065, 1066, 3, 129, 64, 0, 1066, 216, 1, 0, 0, 0, 1067, 1068, 3, 89, 44, 0, 1068, 1069, 3, 83, 41, 0, 1069, 1070, 3, 93, 46, 0, 1070, 1071, 3, 79, 39, 0, 1071, 1072, 3, 113, 56, 0, 1072, 218, 1, 0, 0, 0, 1073, 1074, 3, 121, 60, 0, 1074, 1075, 3, 83, 41, 0, 1075, 1076, 3, 93, 46, 0, 1076, 1077, 3, 79, 39, 0, 1077, 1078, 3, 113, 56, 0, 1078, 220, 1, 0, 0, 0, 1079, 1080, 3, 89, 44, 0, 1080, 1081, 3, 81, 40, 0, 1081, 1082, 3, 95, 47, 0, 1082, 1083, 3, 105, 52, 0, 1083, 222, 1, 0, 0, 0, 1084, 1085, 5, 58, 0, 0, 1085, 1086, 5, 58, 0, 0, 1086, 224, 1, 0, 0, 0, 1087, 1091, 7, 34, 0, 0, 1088, 1090, 7, 35, 0, 0, 1089, 1088, 1, 0, 0, 0, 1090, 1093, 1, 0, 0, 0, 1091, 1089, 1, 0, 0, 0, 1091, 1092, 1, 0, 0, 0, 1092, 226, 1, 0, 0, 0, 1093, 1091, 1, 0, 0, 0, 1094, 1095, 5, 60, 0, 0, 1095, 228, 1, 0, 0, 0, 1096, 1097, 5, 62, 0, 0, 1097, 230, 1, 0, 0, 0, 1098, 1099, 5, 40, 0, 0, 1099, 232, 1, 0, 0, 0, 1100, 1101, 5, 41, 0, 0, 1101, 234, 1, 0, 0, 0, 1102, 1103, 5, 91, 0, 0, 1103, 236, 1, 0, 0, 0, 1104, 1105, 5, 93, 0, 0, 1105, 238, 1, 0, 0, 0, 1106, 1107, 5, 44, 0, 0, 1107, 240, 1, 0, 0, 0, 1108, 1109, 5, 61, 0, 0, 1109, 242, 1, 0, 0, 0, 1110, 1111, 5, 58, 0, 0, 1111, 244, 1, 0, 0, 0, 1112, 1113, 5, 63, 0, 0, 1113, 246, 1, 0, 0, 0, 1114, 1115, 5, 35, 0, 0, 1115, 248, 1, 0, 0, 0, 1116, 1117, 5, 46, 0, 0, 1117, 250, 1, 0, 0, 0, 48, 0, 282, 288, 290, 321, 325, 408, 413, 418, 424, 426, 429, 434, 440, 443, 447, 452, 454, 457, 472, 483, 509, 511, 535, 537, 551, 553, 588, 598, 607, 617, 624, 629, 634, 641, 646, 653, 658, 671, 673, 684, 696, 699, 704, 715, 778, 781, 1091, 1, 0, 1, 0] \ No newline at end of file diff --git a/tests/coverage/antlr_parser/TestFileLexer.py b/tests/coverage/antlr_parser/TestFileLexer.py new file mode 100644 index 000000000..6f83b48b4 --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileLexer.py @@ -0,0 +1,593 @@ +# Generated from TestFileLexer.g4 by ANTLR 4.13.2 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + return [ + 4,0,94,1118,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, + 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, + 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, + 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, + 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, + 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, + 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, + 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, + 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, + 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, + 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, + 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, + 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, + 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2, + 91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7, + 97,2,98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103, + 7,103,2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108, + 2,109,7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114, + 7,114,2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119, + 2,120,7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,1,0, + 1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, + 1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,4,1,281,8,1,11,1, + 12,1,282,1,1,1,1,4,1,287,8,1,11,1,12,1,288,3,1,291,8,1,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, + 2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,5,3,320,8,3,10,3,12,3,323,9,3, + 1,3,3,3,326,8,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,5, + 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6, + 1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8, + 1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1, + 10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1, + 11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13,3,13,409,8,13,1,13,1, + 13,1,14,3,14,414,8,14,1,14,4,14,417,8,14,11,14,12,14,418,1,14,1, + 14,4,14,423,8,14,11,14,12,14,424,3,14,427,8,14,1,15,3,15,430,8,15, + 1,15,4,15,433,8,15,11,15,12,15,434,1,15,1,15,5,15,439,8,15,10,15, + 12,15,442,9,15,3,15,444,8,15,1,15,1,15,3,15,448,8,15,1,15,4,15,451, + 8,15,11,15,12,15,452,3,15,455,8,15,1,15,3,15,458,8,15,1,15,1,15, + 1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,473, + 8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,484,8,16, + 1,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,19, + 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,4,19,508,8,19,11,19, + 12,19,509,3,19,512,8,19,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20, + 1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,4,20, + 534,8,20,11,20,12,20,535,3,20,538,8,20,1,20,1,20,1,21,1,21,1,21, + 1,21,1,21,1,21,1,21,1,21,4,21,550,8,21,11,21,12,21,551,3,21,554, + 8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,23,1,23, + 1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30, + 1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,589,8,31,1,31,1,31, + 1,31,1,31,1,31,1,31,1,31,1,31,3,31,599,8,31,1,32,1,32,1,32,1,32, + 1,32,1,32,1,32,3,32,608,8,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32, + 1,32,3,32,618,8,32,1,33,1,33,1,33,1,33,1,33,3,33,625,8,33,1,33,1, + 33,1,33,3,33,630,8,33,1,33,1,33,1,33,3,33,635,8,33,1,33,1,33,1,33, + 1,33,1,33,3,33,642,8,33,1,33,1,33,1,33,3,33,647,8,33,1,33,1,33,1, + 33,1,33,1,33,3,33,654,8,33,1,33,1,33,1,33,3,33,659,8,33,1,34,1,34, + 1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,5,35,672,8,35,10,35, + 12,35,675,9,35,1,35,1,35,1,36,1,36,1,36,1,36,5,36,683,8,36,10,36, + 12,36,686,9,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,4,37,695,8,37, + 11,37,12,37,696,1,37,3,37,700,8,37,1,37,5,37,703,8,37,10,37,12,37, + 706,9,37,1,37,1,37,1,37,1,37,1,37,1,38,4,38,714,8,38,11,38,12,38, + 715,1,38,1,38,1,39,1,39,1,40,1,40,1,41,1,41,1,42,1,42,1,43,1,43, + 1,44,1,44,1,45,1,45,1,46,1,46,1,47,1,47,1,48,1,48,1,49,1,49,1,50, + 1,50,1,51,1,51,1,52,1,52,1,53,1,53,1,54,1,54,1,55,1,55,1,56,1,56, + 1,57,1,57,1,58,1,58,1,59,1,59,1,60,1,60,1,61,1,61,1,62,1,62,1,63, + 1,63,1,64,1,64,1,65,1,65,1,66,1,66,1,66,5,66,777,8,66,10,66,12,66, + 780,9,66,3,66,782,8,66,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1, + 69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1, + 71,1,71,1,71,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1,74,1,74,1, + 74,1,74,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1,76,1,77,1, + 77,1,77,1,77,1,77,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1, + 79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1,80,1,80,1, + 80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,81,1,81,1,81,1, + 81,1,81,1,82,1,82,1,82,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83,1, + 83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1, + 84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,85,1,85,1,85,1,85,1,85,1, + 86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1,87,1,87,1, + 87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1, + 87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1, + 88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,89,1, + 89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,90,1,90,1,90,1,90,1, + 90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1, + 91,1,91,1,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,93,1,93,1,93,1, + 93,1,93,1,93,1,93,1,93,1,94,1,94,1,94,1,94,1,94,1,95,1,95,1,95,1, + 95,1,96,1,96,1,96,1,96,1,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1, + 99,1,99,1,99,1,99,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101, + 1,102,1,102,1,102,1,102,1,102,1,103,1,103,1,103,1,103,1,103,1,103, + 1,104,1,104,1,104,1,104,1,104,1,105,1,105,1,105,1,105,1,106,1,106, + 1,106,1,106,1,107,1,107,1,107,1,107,1,107,1,107,1,108,1,108,1,108, + 1,108,1,108,1,108,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110, + 1,110,1,110,1,110,1,111,1,111,1,111,1,112,1,112,5,112,1090,8,112, + 10,112,12,112,1093,9,112,1,113,1,113,1,114,1,114,1,115,1,115,1,116, + 1,116,1,117,1,117,1,118,1,118,1,119,1,119,1,120,1,120,1,121,1,121, + 1,122,1,122,1,123,1,123,1,124,1,124,0,0,125,1,1,3,2,5,3,7,4,9,5, + 11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,15,31,16,33, + 17,35,0,37,0,39,18,41,19,43,20,45,21,47,22,49,23,51,24,53,25,55, + 26,57,27,59,28,61,29,63,30,65,31,67,0,69,32,71,33,73,34,75,35,77, + 36,79,0,81,0,83,0,85,0,87,0,89,0,91,0,93,0,95,0,97,0,99,0,101,0, + 103,0,105,0,107,0,109,0,111,0,113,0,115,0,117,0,119,0,121,0,123, + 0,125,0,127,0,129,0,131,0,133,0,135,37,137,38,139,39,141,40,143, + 41,145,42,147,43,149,44,151,45,153,46,155,47,157,48,159,49,161,50, + 163,51,165,52,167,53,169,54,171,55,173,56,175,57,177,58,179,59,181, + 60,183,61,185,62,187,63,189,64,191,65,193,66,195,67,197,68,199,69, + 201,70,203,71,205,72,207,73,209,74,211,75,213,76,215,77,217,78,219, + 79,221,80,223,81,225,82,227,83,229,84,231,85,233,86,235,87,237,88, + 239,89,241,90,243,91,245,92,247,93,249,94,1,0,36,2,0,10,10,13,13, + 2,0,43,43,45,45,1,0,48,57,2,0,69,69,101,101,2,0,39,39,92,92,1,0, + 42,42,2,0,42,42,47,47,3,0,9,10,13,13,32,32,2,0,65,65,97,97,2,0,66, + 66,98,98,2,0,67,67,99,99,2,0,68,68,100,100,2,0,70,70,102,102,2,0, + 71,71,103,103,2,0,72,72,104,104,2,0,73,73,105,105,2,0,74,74,106, + 106,2,0,75,75,107,107,2,0,76,76,108,108,2,0,77,77,109,109,2,0,78, + 78,110,110,2,0,79,79,111,111,2,0,80,80,112,112,2,0,81,81,113,113, + 2,0,82,82,114,114,2,0,83,83,115,115,2,0,84,84,116,116,2,0,85,85, + 117,117,2,0,86,86,118,118,2,0,87,87,119,119,2,0,88,88,120,120,2, + 0,89,89,121,121,2,0,90,90,122,122,1,0,49,57,3,0,65,90,95,95,97,122, + 4,0,48,57,65,90,95,95,97,122,1139,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1, + 0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0, + 0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0, + 0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,39,1,0, + 0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0, + 0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0, + 0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,69,1,0,0,0,0,71,1,0, + 0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,135,1,0,0,0,0,137,1, + 0,0,0,0,139,1,0,0,0,0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0, + 147,1,0,0,0,0,149,1,0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0, + 0,0,0,157,1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165, + 1,0,0,0,0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0, + 0,175,1,0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,0,0,0,0,183,1, + 0,0,0,0,185,1,0,0,0,0,187,1,0,0,0,0,189,1,0,0,0,0,191,1,0,0,0,0, + 193,1,0,0,0,0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0,0,0,0,201,1,0, + 0,0,0,203,1,0,0,0,0,205,1,0,0,0,0,207,1,0,0,0,0,209,1,0,0,0,0,211, + 1,0,0,0,0,213,1,0,0,0,0,215,1,0,0,0,0,217,1,0,0,0,0,219,1,0,0,0, + 0,221,1,0,0,0,0,223,1,0,0,0,0,225,1,0,0,0,0,227,1,0,0,0,0,229,1, + 0,0,0,0,231,1,0,0,0,0,233,1,0,0,0,0,235,1,0,0,0,0,237,1,0,0,0,0, + 239,1,0,0,0,0,241,1,0,0,0,0,243,1,0,0,0,0,245,1,0,0,0,0,247,1,0, + 0,0,0,249,1,0,0,0,1,251,1,0,0,0,3,278,1,0,0,0,5,292,1,0,0,0,7,315, + 1,0,0,0,9,329,1,0,0,0,11,338,1,0,0,0,13,351,1,0,0,0,15,360,1,0,0, + 0,17,369,1,0,0,0,19,375,1,0,0,0,21,384,1,0,0,0,23,391,1,0,0,0,25, + 403,1,0,0,0,27,408,1,0,0,0,29,413,1,0,0,0,31,472,1,0,0,0,33,483, + 1,0,0,0,35,485,1,0,0,0,37,490,1,0,0,0,39,493,1,0,0,0,41,519,1,0, + 0,0,43,541,1,0,0,0,45,557,1,0,0,0,47,565,1,0,0,0,49,567,1,0,0,0, + 51,569,1,0,0,0,53,571,1,0,0,0,55,573,1,0,0,0,57,575,1,0,0,0,59,577, + 1,0,0,0,61,579,1,0,0,0,63,598,1,0,0,0,65,617,1,0,0,0,67,658,1,0, + 0,0,69,660,1,0,0,0,71,665,1,0,0,0,73,678,1,0,0,0,75,689,1,0,0,0, + 77,713,1,0,0,0,79,719,1,0,0,0,81,721,1,0,0,0,83,723,1,0,0,0,85,725, + 1,0,0,0,87,727,1,0,0,0,89,729,1,0,0,0,91,731,1,0,0,0,93,733,1,0, + 0,0,95,735,1,0,0,0,97,737,1,0,0,0,99,739,1,0,0,0,101,741,1,0,0,0, + 103,743,1,0,0,0,105,745,1,0,0,0,107,747,1,0,0,0,109,749,1,0,0,0, + 111,751,1,0,0,0,113,753,1,0,0,0,115,755,1,0,0,0,117,757,1,0,0,0, + 119,759,1,0,0,0,121,761,1,0,0,0,123,763,1,0,0,0,125,765,1,0,0,0, + 127,767,1,0,0,0,129,769,1,0,0,0,131,771,1,0,0,0,133,781,1,0,0,0, + 135,783,1,0,0,0,137,786,1,0,0,0,139,791,1,0,0,0,141,796,1,0,0,0, + 143,804,1,0,0,0,145,807,1,0,0,0,147,811,1,0,0,0,149,815,1,0,0,0, + 151,819,1,0,0,0,153,824,1,0,0,0,155,829,1,0,0,0,157,836,1,0,0,0, + 159,843,1,0,0,0,161,853,1,0,0,0,163,866,1,0,0,0,165,871,1,0,0,0, + 167,876,1,0,0,0,169,890,1,0,0,0,171,903,1,0,0,0,173,908,1,0,0,0, + 175,916,1,0,0,0,177,936,1,0,0,0,179,959,1,0,0,0,181,969,1,0,0,0, + 183,977,1,0,0,0,185,989,1,0,0,0,187,996,1,0,0,0,189,1004,1,0,0,0, + 191,1009,1,0,0,0,193,1013,1,0,0,0,195,1017,1,0,0,0,197,1020,1,0, + 0,0,199,1025,1,0,0,0,201,1029,1,0,0,0,203,1034,1,0,0,0,205,1037, + 1,0,0,0,207,1042,1,0,0,0,209,1048,1,0,0,0,211,1053,1,0,0,0,213,1057, + 1,0,0,0,215,1061,1,0,0,0,217,1067,1,0,0,0,219,1073,1,0,0,0,221,1079, + 1,0,0,0,223,1084,1,0,0,0,225,1087,1,0,0,0,227,1094,1,0,0,0,229,1096, + 1,0,0,0,231,1098,1,0,0,0,233,1100,1,0,0,0,235,1102,1,0,0,0,237,1104, + 1,0,0,0,239,1106,1,0,0,0,241,1108,1,0,0,0,243,1110,1,0,0,0,245,1112, + 1,0,0,0,247,1114,1,0,0,0,249,1116,1,0,0,0,251,252,5,35,0,0,252,253, + 5,35,0,0,253,254,5,35,0,0,254,255,5,32,0,0,255,256,5,83,0,0,256, + 257,5,85,0,0,257,258,5,66,0,0,258,259,5,83,0,0,259,260,5,84,0,0, + 260,261,5,82,0,0,261,262,5,65,0,0,262,263,5,73,0,0,263,264,5,84, + 0,0,264,265,5,95,0,0,265,266,5,83,0,0,266,267,5,67,0,0,267,268,5, + 65,0,0,268,269,5,76,0,0,269,270,5,65,0,0,270,271,5,82,0,0,271,272, + 5,95,0,0,272,273,5,84,0,0,273,274,5,69,0,0,274,275,5,83,0,0,275, + 276,5,84,0,0,276,277,5,58,0,0,277,2,1,0,0,0,278,280,5,118,0,0,279, + 281,3,131,65,0,280,279,1,0,0,0,281,282,1,0,0,0,282,280,1,0,0,0,282, + 283,1,0,0,0,283,290,1,0,0,0,284,286,5,46,0,0,285,287,3,131,65,0, + 286,285,1,0,0,0,287,288,1,0,0,0,288,286,1,0,0,0,288,289,1,0,0,0, + 289,291,1,0,0,0,290,284,1,0,0,0,290,291,1,0,0,0,291,4,1,0,0,0,292, + 293,5,35,0,0,293,294,5,35,0,0,294,295,5,35,0,0,295,296,5,32,0,0, + 296,297,5,83,0,0,297,298,5,85,0,0,298,299,5,66,0,0,299,300,5,83, + 0,0,300,301,5,84,0,0,301,302,5,82,0,0,302,303,5,65,0,0,303,304,5, + 73,0,0,304,305,5,84,0,0,305,306,5,95,0,0,306,307,5,73,0,0,307,308, + 5,78,0,0,308,309,5,67,0,0,309,310,5,76,0,0,310,311,5,85,0,0,311, + 312,5,68,0,0,312,313,5,69,0,0,313,314,5,58,0,0,314,6,1,0,0,0,315, + 316,5,35,0,0,316,317,5,32,0,0,317,321,1,0,0,0,318,320,8,0,0,0,319, + 318,1,0,0,0,320,323,1,0,0,0,321,319,1,0,0,0,321,322,1,0,0,0,322, + 325,1,0,0,0,323,321,1,0,0,0,324,326,5,13,0,0,325,324,1,0,0,0,325, + 326,1,0,0,0,326,327,1,0,0,0,327,328,5,10,0,0,328,8,1,0,0,0,329,330, + 5,60,0,0,330,331,5,33,0,0,331,332,5,69,0,0,332,333,5,82,0,0,333, + 334,5,82,0,0,334,335,5,79,0,0,335,336,5,82,0,0,336,337,5,62,0,0, + 337,10,1,0,0,0,338,339,5,60,0,0,339,340,5,33,0,0,340,341,5,85,0, + 0,341,342,5,78,0,0,342,343,5,68,0,0,343,344,5,69,0,0,344,345,5,70, + 0,0,345,346,5,73,0,0,346,347,5,78,0,0,347,348,5,69,0,0,348,349,5, + 68,0,0,349,350,5,62,0,0,350,12,1,0,0,0,351,352,5,111,0,0,352,353, + 5,118,0,0,353,354,5,101,0,0,354,355,5,114,0,0,355,356,5,108,0,0, + 356,357,5,102,0,0,357,358,5,111,0,0,358,359,5,119,0,0,359,14,1,0, + 0,0,360,361,5,114,0,0,361,362,5,111,0,0,362,363,5,117,0,0,363,364, + 5,110,0,0,364,365,5,100,0,0,365,366,5,105,0,0,366,367,5,110,0,0, + 367,368,5,103,0,0,368,16,1,0,0,0,369,370,5,69,0,0,370,371,5,82,0, + 0,371,372,5,82,0,0,372,373,5,79,0,0,373,374,5,82,0,0,374,18,1,0, + 0,0,375,376,5,83,0,0,376,377,5,65,0,0,377,378,5,84,0,0,378,379,5, + 85,0,0,379,380,5,82,0,0,380,381,5,65,0,0,381,382,5,84,0,0,382,383, + 5,69,0,0,383,20,1,0,0,0,384,385,5,83,0,0,385,386,5,73,0,0,386,387, + 5,76,0,0,387,388,5,69,0,0,388,389,5,78,0,0,389,390,5,84,0,0,390, + 22,1,0,0,0,391,392,5,84,0,0,392,393,5,73,0,0,393,394,5,69,0,0,394, + 395,5,95,0,0,395,396,5,84,0,0,396,397,5,79,0,0,397,398,5,95,0,0, + 398,399,5,69,0,0,399,400,5,86,0,0,400,401,5,69,0,0,401,402,5,78, + 0,0,402,24,1,0,0,0,403,404,5,78,0,0,404,405,5,65,0,0,405,406,5,78, + 0,0,406,26,1,0,0,0,407,409,7,1,0,0,408,407,1,0,0,0,408,409,1,0,0, + 0,409,410,1,0,0,0,410,411,3,133,66,0,411,28,1,0,0,0,412,414,7,1, + 0,0,413,412,1,0,0,0,413,414,1,0,0,0,414,416,1,0,0,0,415,417,7,2, + 0,0,416,415,1,0,0,0,417,418,1,0,0,0,418,416,1,0,0,0,418,419,1,0, + 0,0,419,426,1,0,0,0,420,422,5,46,0,0,421,423,7,2,0,0,422,421,1,0, + 0,0,423,424,1,0,0,0,424,422,1,0,0,0,424,425,1,0,0,0,425,427,1,0, + 0,0,426,420,1,0,0,0,426,427,1,0,0,0,427,30,1,0,0,0,428,430,7,1,0, + 0,429,428,1,0,0,0,429,430,1,0,0,0,430,432,1,0,0,0,431,433,7,2,0, + 0,432,431,1,0,0,0,433,434,1,0,0,0,434,432,1,0,0,0,434,435,1,0,0, + 0,435,443,1,0,0,0,436,440,5,46,0,0,437,439,7,2,0,0,438,437,1,0,0, + 0,439,442,1,0,0,0,440,438,1,0,0,0,440,441,1,0,0,0,441,444,1,0,0, + 0,442,440,1,0,0,0,443,436,1,0,0,0,443,444,1,0,0,0,444,454,1,0,0, + 0,445,447,7,3,0,0,446,448,7,1,0,0,447,446,1,0,0,0,447,448,1,0,0, + 0,448,450,1,0,0,0,449,451,7,2,0,0,450,449,1,0,0,0,451,452,1,0,0, + 0,452,450,1,0,0,0,452,453,1,0,0,0,453,455,1,0,0,0,454,445,1,0,0, + 0,454,455,1,0,0,0,455,473,1,0,0,0,456,458,7,1,0,0,457,456,1,0,0, + 0,457,458,1,0,0,0,458,459,1,0,0,0,459,460,5,105,0,0,460,461,5,110, + 0,0,461,473,5,102,0,0,462,463,5,110,0,0,463,464,5,97,0,0,464,473, + 5,110,0,0,465,466,5,78,0,0,466,467,5,97,0,0,467,473,5,78,0,0,468, + 469,5,115,0,0,469,470,5,110,0,0,470,471,5,97,0,0,471,473,5,110,0, + 0,472,429,1,0,0,0,472,457,1,0,0,0,472,462,1,0,0,0,472,465,1,0,0, + 0,472,468,1,0,0,0,473,32,1,0,0,0,474,475,5,116,0,0,475,476,5,114, + 0,0,476,477,5,117,0,0,477,484,5,101,0,0,478,479,5,102,0,0,479,480, + 5,97,0,0,480,481,5,108,0,0,481,482,5,115,0,0,482,484,5,101,0,0,483, + 474,1,0,0,0,483,478,1,0,0,0,484,34,1,0,0,0,485,486,7,2,0,0,486,487, + 7,2,0,0,487,488,7,2,0,0,488,489,7,2,0,0,489,36,1,0,0,0,490,491,7, + 2,0,0,491,492,7,2,0,0,492,38,1,0,0,0,493,494,5,39,0,0,494,495,3, + 35,17,0,495,496,5,45,0,0,496,497,3,37,18,0,497,498,5,45,0,0,498, + 499,3,37,18,0,499,500,5,84,0,0,500,501,3,37,18,0,501,502,5,58,0, + 0,502,503,3,37,18,0,503,504,5,58,0,0,504,511,3,37,18,0,505,507,5, + 46,0,0,506,508,7,2,0,0,507,506,1,0,0,0,508,509,1,0,0,0,509,507,1, + 0,0,0,509,510,1,0,0,0,510,512,1,0,0,0,511,505,1,0,0,0,511,512,1, + 0,0,0,512,513,1,0,0,0,513,514,7,1,0,0,514,515,3,37,18,0,515,516, + 5,58,0,0,516,517,3,37,18,0,517,518,5,39,0,0,518,40,1,0,0,0,519,520, + 5,39,0,0,520,521,3,35,17,0,521,522,5,45,0,0,522,523,3,37,18,0,523, + 524,5,45,0,0,524,525,3,37,18,0,525,526,5,84,0,0,526,527,3,37,18, + 0,527,528,5,58,0,0,528,529,3,37,18,0,529,530,5,58,0,0,530,537,3, + 37,18,0,531,533,5,46,0,0,532,534,7,2,0,0,533,532,1,0,0,0,534,535, + 1,0,0,0,535,533,1,0,0,0,535,536,1,0,0,0,536,538,1,0,0,0,537,531, + 1,0,0,0,537,538,1,0,0,0,538,539,1,0,0,0,539,540,5,39,0,0,540,42, + 1,0,0,0,541,542,5,39,0,0,542,543,3,37,18,0,543,544,5,58,0,0,544, + 545,3,37,18,0,545,546,5,58,0,0,546,553,3,37,18,0,547,549,5,46,0, + 0,548,550,7,2,0,0,549,548,1,0,0,0,550,551,1,0,0,0,551,549,1,0,0, + 0,551,552,1,0,0,0,552,554,1,0,0,0,553,547,1,0,0,0,553,554,1,0,0, + 0,554,555,1,0,0,0,555,556,5,39,0,0,556,44,1,0,0,0,557,558,5,39,0, + 0,558,559,3,35,17,0,559,560,5,45,0,0,560,561,3,37,18,0,561,562,5, + 45,0,0,562,563,3,37,18,0,563,564,5,39,0,0,564,46,1,0,0,0,565,566, + 5,80,0,0,566,48,1,0,0,0,567,568,5,84,0,0,568,50,1,0,0,0,569,570, + 5,89,0,0,570,52,1,0,0,0,571,572,5,77,0,0,572,54,1,0,0,0,573,574, + 5,68,0,0,574,56,1,0,0,0,575,576,5,72,0,0,576,58,1,0,0,0,577,578, + 5,83,0,0,578,60,1,0,0,0,579,580,5,70,0,0,580,62,1,0,0,0,581,582, + 5,39,0,0,582,583,3,47,23,0,583,584,3,27,13,0,584,588,3,51,25,0,585, + 586,3,27,13,0,586,587,3,53,26,0,587,589,1,0,0,0,588,585,1,0,0,0, + 588,589,1,0,0,0,589,590,1,0,0,0,590,591,5,39,0,0,591,599,1,0,0,0, + 592,593,5,39,0,0,593,594,3,47,23,0,594,595,3,27,13,0,595,596,3,53, + 26,0,596,597,5,39,0,0,597,599,1,0,0,0,598,581,1,0,0,0,598,592,1, + 0,0,0,599,64,1,0,0,0,600,601,5,39,0,0,601,602,3,47,23,0,602,603, + 3,27,13,0,603,607,3,55,27,0,604,605,3,49,24,0,605,606,3,67,33,0, + 606,608,1,0,0,0,607,604,1,0,0,0,607,608,1,0,0,0,608,609,1,0,0,0, + 609,610,5,39,0,0,610,618,1,0,0,0,611,612,5,39,0,0,612,613,3,47,23, + 0,613,614,3,49,24,0,614,615,3,67,33,0,615,616,5,39,0,0,616,618,1, + 0,0,0,617,600,1,0,0,0,617,611,1,0,0,0,618,66,1,0,0,0,619,620,3,27, + 13,0,620,624,3,57,28,0,621,622,3,27,13,0,622,623,3,53,26,0,623,625, + 1,0,0,0,624,621,1,0,0,0,624,625,1,0,0,0,625,629,1,0,0,0,626,627, + 3,27,13,0,627,628,3,59,29,0,628,630,1,0,0,0,629,626,1,0,0,0,629, + 630,1,0,0,0,630,634,1,0,0,0,631,632,3,27,13,0,632,633,3,61,30,0, + 633,635,1,0,0,0,634,631,1,0,0,0,634,635,1,0,0,0,635,659,1,0,0,0, + 636,637,3,27,13,0,637,641,3,53,26,0,638,639,3,27,13,0,639,640,3, + 59,29,0,640,642,1,0,0,0,641,638,1,0,0,0,641,642,1,0,0,0,642,646, + 1,0,0,0,643,644,3,27,13,0,644,645,3,61,30,0,645,647,1,0,0,0,646, + 643,1,0,0,0,646,647,1,0,0,0,647,659,1,0,0,0,648,649,3,27,13,0,649, + 653,3,59,29,0,650,651,3,27,13,0,651,652,3,61,30,0,652,654,1,0,0, + 0,653,650,1,0,0,0,653,654,1,0,0,0,654,659,1,0,0,0,655,656,3,27,13, + 0,656,657,3,61,30,0,657,659,1,0,0,0,658,619,1,0,0,0,658,636,1,0, + 0,0,658,648,1,0,0,0,658,655,1,0,0,0,659,68,1,0,0,0,660,661,5,110, + 0,0,661,662,5,117,0,0,662,663,5,108,0,0,663,664,5,108,0,0,664,70, + 1,0,0,0,665,673,5,39,0,0,666,667,5,92,0,0,667,672,9,0,0,0,668,669, + 5,39,0,0,669,672,5,39,0,0,670,672,8,4,0,0,671,666,1,0,0,0,671,668, + 1,0,0,0,671,670,1,0,0,0,672,675,1,0,0,0,673,671,1,0,0,0,673,674, + 1,0,0,0,674,676,1,0,0,0,675,673,1,0,0,0,676,677,5,39,0,0,677,72, + 1,0,0,0,678,679,5,47,0,0,679,680,5,47,0,0,680,684,1,0,0,0,681,683, + 8,0,0,0,682,681,1,0,0,0,683,686,1,0,0,0,684,682,1,0,0,0,684,685, + 1,0,0,0,685,687,1,0,0,0,686,684,1,0,0,0,687,688,6,36,0,0,688,74, + 1,0,0,0,689,690,5,47,0,0,690,691,5,42,0,0,691,699,1,0,0,0,692,700, + 8,5,0,0,693,695,5,42,0,0,694,693,1,0,0,0,695,696,1,0,0,0,696,694, + 1,0,0,0,696,697,1,0,0,0,697,698,1,0,0,0,698,700,8,6,0,0,699,692, + 1,0,0,0,699,694,1,0,0,0,700,704,1,0,0,0,701,703,5,42,0,0,702,701, + 1,0,0,0,703,706,1,0,0,0,704,702,1,0,0,0,704,705,1,0,0,0,705,707, + 1,0,0,0,706,704,1,0,0,0,707,708,5,42,0,0,708,709,5,47,0,0,709,710, + 1,0,0,0,710,711,6,37,0,0,711,76,1,0,0,0,712,714,7,7,0,0,713,712, + 1,0,0,0,714,715,1,0,0,0,715,713,1,0,0,0,715,716,1,0,0,0,716,717, + 1,0,0,0,717,718,6,38,0,0,718,78,1,0,0,0,719,720,7,8,0,0,720,80,1, + 0,0,0,721,722,7,9,0,0,722,82,1,0,0,0,723,724,7,10,0,0,724,84,1,0, + 0,0,725,726,7,11,0,0,726,86,1,0,0,0,727,728,7,3,0,0,728,88,1,0,0, + 0,729,730,7,12,0,0,730,90,1,0,0,0,731,732,7,13,0,0,732,92,1,0,0, + 0,733,734,7,14,0,0,734,94,1,0,0,0,735,736,7,15,0,0,736,96,1,0,0, + 0,737,738,7,16,0,0,738,98,1,0,0,0,739,740,7,17,0,0,740,100,1,0,0, + 0,741,742,7,18,0,0,742,102,1,0,0,0,743,744,7,19,0,0,744,104,1,0, + 0,0,745,746,7,20,0,0,746,106,1,0,0,0,747,748,7,21,0,0,748,108,1, + 0,0,0,749,750,7,22,0,0,750,110,1,0,0,0,751,752,7,23,0,0,752,112, + 1,0,0,0,753,754,7,24,0,0,754,114,1,0,0,0,755,756,7,25,0,0,756,116, + 1,0,0,0,757,758,7,26,0,0,758,118,1,0,0,0,759,760,7,27,0,0,760,120, + 1,0,0,0,761,762,7,28,0,0,762,122,1,0,0,0,763,764,7,29,0,0,764,124, + 1,0,0,0,765,766,7,30,0,0,766,126,1,0,0,0,767,768,7,31,0,0,768,128, + 1,0,0,0,769,770,7,32,0,0,770,130,1,0,0,0,771,772,7,2,0,0,772,132, + 1,0,0,0,773,782,5,48,0,0,774,778,7,33,0,0,775,777,7,2,0,0,776,775, + 1,0,0,0,777,780,1,0,0,0,778,776,1,0,0,0,778,779,1,0,0,0,779,782, + 1,0,0,0,780,778,1,0,0,0,781,773,1,0,0,0,781,774,1,0,0,0,782,134, + 1,0,0,0,783,784,3,95,47,0,784,785,3,89,44,0,785,136,1,0,0,0,786, + 787,3,117,58,0,787,788,3,93,46,0,788,789,3,87,43,0,789,790,3,105, + 52,0,790,138,1,0,0,0,791,792,3,87,43,0,792,793,3,101,50,0,793,794, + 3,115,57,0,794,795,3,87,43,0,795,140,1,0,0,0,796,797,3,81,40,0,797, + 798,3,107,53,0,798,799,3,107,53,0,799,800,3,101,50,0,800,801,3,87, + 43,0,801,802,3,79,39,0,802,803,3,105,52,0,803,142,1,0,0,0,804,805, + 3,95,47,0,805,806,5,56,0,0,806,144,1,0,0,0,807,808,3,95,47,0,808, + 809,5,49,0,0,809,810,5,54,0,0,810,146,1,0,0,0,811,812,3,95,47,0, + 812,813,5,51,0,0,813,814,5,50,0,0,814,148,1,0,0,0,815,816,3,95,47, + 0,816,817,5,54,0,0,817,818,5,52,0,0,818,150,1,0,0,0,819,820,3,89, + 44,0,820,821,3,109,54,0,821,822,5,51,0,0,822,823,5,50,0,0,823,152, + 1,0,0,0,824,825,3,89,44,0,825,826,3,109,54,0,826,827,5,54,0,0,827, + 828,5,52,0,0,828,154,1,0,0,0,829,830,3,115,57,0,830,831,3,117,58, + 0,831,832,3,113,56,0,832,833,3,95,47,0,833,834,3,105,52,0,834,835, + 3,91,45,0,835,156,1,0,0,0,836,837,3,81,40,0,837,838,3,95,47,0,838, + 839,3,105,52,0,839,840,3,79,39,0,840,841,3,113,56,0,841,842,3,127, + 63,0,842,158,1,0,0,0,843,844,3,117,58,0,844,845,3,95,47,0,845,846, + 3,103,51,0,846,847,3,87,43,0,847,848,3,115,57,0,848,849,3,117,58, + 0,849,850,3,79,39,0,850,851,3,103,51,0,851,852,3,109,54,0,852,160, + 1,0,0,0,853,854,3,117,58,0,854,855,3,95,47,0,855,856,3,103,51,0, + 856,857,3,87,43,0,857,858,3,115,57,0,858,859,3,117,58,0,859,860, + 3,79,39,0,860,861,3,103,51,0,861,862,3,109,54,0,862,863,5,95,0,0, + 863,864,3,117,58,0,864,865,3,129,64,0,865,162,1,0,0,0,866,867,3, + 85,42,0,867,868,3,79,39,0,868,869,3,117,58,0,869,870,3,87,43,0,870, + 164,1,0,0,0,871,872,3,117,58,0,872,873,3,95,47,0,873,874,3,103,51, + 0,874,875,3,87,43,0,875,166,1,0,0,0,876,877,3,95,47,0,877,878,3, + 105,52,0,878,879,3,117,58,0,879,880,3,87,43,0,880,881,3,113,56,0, + 881,882,3,121,60,0,882,883,3,79,39,0,883,884,3,101,50,0,884,885, + 5,95,0,0,885,886,3,127,63,0,886,887,3,87,43,0,887,888,3,79,39,0, + 888,889,3,113,56,0,889,168,1,0,0,0,890,891,3,95,47,0,891,892,3,105, + 52,0,892,893,3,117,58,0,893,894,3,87,43,0,894,895,3,113,56,0,895, + 896,3,121,60,0,896,897,3,79,39,0,897,898,3,101,50,0,898,899,5,95, + 0,0,899,900,3,85,42,0,900,901,3,79,39,0,901,902,3,127,63,0,902,170, + 1,0,0,0,903,904,3,119,59,0,904,905,3,119,59,0,905,906,3,95,47,0, + 906,907,3,85,42,0,907,172,1,0,0,0,908,909,3,85,42,0,909,910,3,87, + 43,0,910,911,3,83,41,0,911,912,3,95,47,0,912,913,3,103,51,0,913, + 914,3,79,39,0,914,915,3,101,50,0,915,174,1,0,0,0,916,917,3,109,54, + 0,917,918,3,113,56,0,918,919,3,87,43,0,919,920,3,83,41,0,920,921, + 3,95,47,0,921,922,3,115,57,0,922,923,3,95,47,0,923,924,3,107,53, + 0,924,925,3,105,52,0,925,926,5,95,0,0,926,927,3,117,58,0,927,928, + 3,95,47,0,928,929,3,103,51,0,929,930,3,87,43,0,930,931,3,115,57, + 0,931,932,3,117,58,0,932,933,3,79,39,0,933,934,3,103,51,0,934,935, + 3,109,54,0,935,176,1,0,0,0,936,937,3,109,54,0,937,938,3,113,56,0, + 938,939,3,87,43,0,939,940,3,83,41,0,940,941,3,95,47,0,941,942,3, + 115,57,0,942,943,3,95,47,0,943,944,3,107,53,0,944,945,3,105,52,0, + 945,946,5,95,0,0,946,947,3,117,58,0,947,948,3,95,47,0,948,949,3, + 103,51,0,949,950,3,87,43,0,950,951,3,115,57,0,951,952,3,117,58,0, + 952,953,3,79,39,0,953,954,3,103,51,0,954,955,3,109,54,0,955,956, + 5,95,0,0,956,957,3,117,58,0,957,958,3,129,64,0,958,178,1,0,0,0,959, + 960,3,89,44,0,960,961,3,95,47,0,961,962,3,125,62,0,962,963,3,87, + 43,0,963,964,3,85,42,0,964,965,3,83,41,0,965,966,3,93,46,0,966,967, + 3,79,39,0,967,968,3,113,56,0,968,180,1,0,0,0,969,970,3,121,60,0, + 970,971,3,79,39,0,971,972,3,113,56,0,972,973,3,83,41,0,973,974,3, + 93,46,0,974,975,3,79,39,0,975,976,3,113,56,0,976,182,1,0,0,0,977, + 978,3,89,44,0,978,979,3,95,47,0,979,980,3,125,62,0,980,981,3,87, + 43,0,981,982,3,85,42,0,982,983,3,81,40,0,983,984,3,95,47,0,984,985, + 3,105,52,0,985,986,3,79,39,0,986,987,3,113,56,0,987,988,3,127,63, + 0,988,184,1,0,0,0,989,990,3,115,57,0,990,991,3,117,58,0,991,992, + 3,113,56,0,992,993,3,119,59,0,993,994,3,83,41,0,994,995,3,117,58, + 0,995,186,1,0,0,0,996,997,3,105,52,0,997,998,3,115,57,0,998,999, + 3,117,58,0,999,1000,3,113,56,0,1000,1001,3,119,59,0,1001,1002,3, + 83,41,0,1002,1003,3,117,58,0,1003,188,1,0,0,0,1004,1005,3,101,50, + 0,1005,1006,3,95,47,0,1006,1007,3,115,57,0,1007,1008,3,117,58,0, + 1008,190,1,0,0,0,1009,1010,3,103,51,0,1010,1011,3,79,39,0,1011,1012, + 3,109,54,0,1012,192,1,0,0,0,1013,1014,3,79,39,0,1014,1015,3,105, + 52,0,1015,1016,3,127,63,0,1016,194,1,0,0,0,1017,1018,3,119,59,0, + 1018,1019,5,33,0,0,1019,196,1,0,0,0,1020,1021,3,81,40,0,1021,1022, + 3,107,53,0,1022,1023,3,107,53,0,1023,1024,3,101,50,0,1024,198,1, + 0,0,0,1025,1026,3,115,57,0,1026,1027,3,117,58,0,1027,1028,3,113, + 56,0,1028,200,1,0,0,0,1029,1030,3,121,60,0,1030,1031,3,81,40,0,1031, + 1032,3,95,47,0,1032,1033,3,105,52,0,1033,202,1,0,0,0,1034,1035,3, + 117,58,0,1035,1036,3,115,57,0,1036,204,1,0,0,0,1037,1038,3,117,58, + 0,1038,1039,3,115,57,0,1039,1040,3,117,58,0,1040,1041,3,129,64,0, + 1041,206,1,0,0,0,1042,1043,3,95,47,0,1043,1044,3,127,63,0,1044,1045, + 3,87,43,0,1045,1046,3,79,39,0,1046,1047,3,113,56,0,1047,208,1,0, + 0,0,1048,1049,3,95,47,0,1049,1050,3,85,42,0,1050,1051,3,79,39,0, + 1051,1052,3,127,63,0,1052,210,1,0,0,0,1053,1054,3,85,42,0,1054,1055, + 3,87,43,0,1055,1056,3,83,41,0,1056,212,1,0,0,0,1057,1058,3,109,54, + 0,1058,1059,3,117,58,0,1059,1060,3,115,57,0,1060,214,1,0,0,0,1061, + 1062,3,109,54,0,1062,1063,3,117,58,0,1063,1064,3,115,57,0,1064,1065, + 3,117,58,0,1065,1066,3,129,64,0,1066,216,1,0,0,0,1067,1068,3,89, + 44,0,1068,1069,3,83,41,0,1069,1070,3,93,46,0,1070,1071,3,79,39,0, + 1071,1072,3,113,56,0,1072,218,1,0,0,0,1073,1074,3,121,60,0,1074, + 1075,3,83,41,0,1075,1076,3,93,46,0,1076,1077,3,79,39,0,1077,1078, + 3,113,56,0,1078,220,1,0,0,0,1079,1080,3,89,44,0,1080,1081,3,81,40, + 0,1081,1082,3,95,47,0,1082,1083,3,105,52,0,1083,222,1,0,0,0,1084, + 1085,5,58,0,0,1085,1086,5,58,0,0,1086,224,1,0,0,0,1087,1091,7,34, + 0,0,1088,1090,7,35,0,0,1089,1088,1,0,0,0,1090,1093,1,0,0,0,1091, + 1089,1,0,0,0,1091,1092,1,0,0,0,1092,226,1,0,0,0,1093,1091,1,0,0, + 0,1094,1095,5,60,0,0,1095,228,1,0,0,0,1096,1097,5,62,0,0,1097,230, + 1,0,0,0,1098,1099,5,40,0,0,1099,232,1,0,0,0,1100,1101,5,41,0,0,1101, + 234,1,0,0,0,1102,1103,5,91,0,0,1103,236,1,0,0,0,1104,1105,5,93,0, + 0,1105,238,1,0,0,0,1106,1107,5,44,0,0,1107,240,1,0,0,0,1108,1109, + 5,61,0,0,1109,242,1,0,0,0,1110,1111,5,58,0,0,1111,244,1,0,0,0,1112, + 1113,5,63,0,0,1113,246,1,0,0,0,1114,1115,5,35,0,0,1115,248,1,0,0, + 0,1116,1117,5,46,0,0,1117,250,1,0,0,0,48,0,282,288,290,321,325,408, + 413,418,424,426,429,434,440,443,447,452,454,457,472,483,509,511, + 535,537,551,553,588,598,607,617,624,629,634,641,646,653,658,671, + 673,684,696,699,704,715,778,781,1091,1,0,1,0 + ] + +class TestFileLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + SUBSTRAIT_SCALAR_TEST = 1 + FORMAT_VERSION = 2 + SUBSTRAIT_INCLUDE = 3 + DESCRIPTION_LINE = 4 + ERROR_RESULT = 5 + UNDEFINED_RESULT = 6 + OVERFLOW = 7 + ROUNDING = 8 + ERROR = 9 + SATURATE = 10 + SILENT = 11 + TIE_TO_EVEN = 12 + NAN = 13 + INTEGER_LITERAL = 14 + DECIMAL_LITERAL = 15 + FLOAT_LITERAL = 16 + BOOLEAN_LITERAL = 17 + TIMESTAMP_TZ_LITERAL = 18 + TIMESTAMP_LITERAL = 19 + TIME_LITERAL = 20 + DATE_LITERAL = 21 + PERIOD_PREFIX = 22 + TIME_PREFIX = 23 + YEAR_SUFFIX = 24 + M_SUFFIX = 25 + DAY_SUFFIX = 26 + HOUR_SUFFIX = 27 + SECOND_SUFFIX = 28 + FRACTIONAL_SECOND_SUFFIX = 29 + INTERVAL_YEAR_LITERAL = 30 + INTERVAL_DAY_LITERAL = 31 + NULL_LITERAL = 32 + STRING_LITERAL = 33 + LineComment = 34 + BlockComment = 35 + Whitespace = 36 + If = 37 + Then = 38 + Else = 39 + Boolean = 40 + I8 = 41 + I16 = 42 + I32 = 43 + I64 = 44 + FP32 = 45 + FP64 = 46 + String = 47 + Binary = 48 + Timestamp = 49 + TimestampTZ = 50 + Date = 51 + Time = 52 + IntervalYear = 53 + IntervalDay = 54 + UUID = 55 + Decimal = 56 + PrecisionTimestamp = 57 + PrecisionTimestampTZ = 58 + FixedChar = 59 + VarChar = 60 + FixedBinary = 61 + Struct = 62 + NStruct = 63 + List = 64 + Map = 65 + ANY = 66 + UserDefined = 67 + Bool = 68 + Str = 69 + VBin = 70 + Ts = 71 + TsTZ = 72 + IYear = 73 + IDay = 74 + Dec = 75 + PTs = 76 + PTsTZ = 77 + FChar = 78 + VChar = 79 + FBin = 80 + DOUBLE_COLON = 81 + IDENTIFIER = 82 + O_ANGLE_BRACKET = 83 + C_ANGLE_BRACKET = 84 + OPAREN = 85 + CPAREN = 86 + OBRACKET = 87 + CBRACKET = 88 + COMMA = 89 + EQ = 90 + COLON = 91 + QMARK = 92 + HASH = 93 + DOT = 94 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'### SUBSTRAIT_SCALAR_TEST:'", "'### SUBSTRAIT_INCLUDE:'", + "''", "''", "'overlfow'", "'rounding'", + "'ERROR'", "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", + "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", "'null'", + "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", + "':'", "'?'", "'#'", "'.'" ] + + symbolicNames = [ "", + "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", "OVERFLOW", + "ROUNDING", "ERROR", "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", + "INTEGER_LITERAL", "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", + "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", + "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", "NULL_LITERAL", + "STRING_LITERAL", "LineComment", "BlockComment", "Whitespace", + "If", "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", + "FP32", "FP64", "String", "Binary", "Timestamp", "TimestampTZ", + "Date", "Time", "IntervalYear", "IntervalDay", "UUID", "Decimal", + "PrecisionTimestamp", "PrecisionTimestampTZ", "FixedChar", "VarChar", + "FixedBinary", "Struct", "NStruct", "List", "Map", "ANY", "UserDefined", + "Bool", "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", + "PTs", "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", + "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", "CPAREN", "OBRACKET", + "CBRACKET", "COMMA", "EQ", "COLON", "QMARK", "HASH", "DOT" ] + + ruleNames = [ "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", + "OVERFLOW", "ROUNDING", "ERROR", "SATURATE", "SILENT", + "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", "DECIMAL_LITERAL", + "FLOAT_LITERAL", "BOOLEAN_LITERAL", "FourDigits", "TwoDigits", + "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", + "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", + "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", + "TIME_INTERVAL", "NULL_LITERAL", "STRING_LITERAL", "LineComment", + "BlockComment", "Whitespace", "A", "B", "C", "D", "E", + "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", + "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "DIGIT", + "INTEGER", "If", "Then", "Else", "Boolean", "I8", "I16", + "I32", "I64", "FP32", "FP64", "String", "Binary", "Timestamp", + "TimestampTZ", "Date", "Time", "IntervalYear", "IntervalDay", + "UUID", "Decimal", "PrecisionTimestamp", "PrecisionTimestampTZ", + "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", + "List", "Map", "ANY", "UserDefined", "Bool", "Str", "VBin", + "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", + "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", + "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", "CPAREN", + "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", "QMARK", + "HASH", "DOT" ] + + grammarFileName = "TestFileLexer.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/tests/coverage/antlr_parser/TestFileLexer.tokens b/tests/coverage/antlr_parser/TestFileLexer.tokens new file mode 100644 index 000000000..a3b65b74e --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileLexer.tokens @@ -0,0 +1,127 @@ +SUBSTRAIT_SCALAR_TEST=1 +FORMAT_VERSION=2 +SUBSTRAIT_INCLUDE=3 +DESCRIPTION_LINE=4 +ERROR_RESULT=5 +UNDEFINED_RESULT=6 +OVERFLOW=7 +ROUNDING=8 +ERROR=9 +SATURATE=10 +SILENT=11 +TIE_TO_EVEN=12 +NAN=13 +INTEGER_LITERAL=14 +DECIMAL_LITERAL=15 +FLOAT_LITERAL=16 +BOOLEAN_LITERAL=17 +TIMESTAMP_TZ_LITERAL=18 +TIMESTAMP_LITERAL=19 +TIME_LITERAL=20 +DATE_LITERAL=21 +PERIOD_PREFIX=22 +TIME_PREFIX=23 +YEAR_SUFFIX=24 +M_SUFFIX=25 +DAY_SUFFIX=26 +HOUR_SUFFIX=27 +SECOND_SUFFIX=28 +FRACTIONAL_SECOND_SUFFIX=29 +INTERVAL_YEAR_LITERAL=30 +INTERVAL_DAY_LITERAL=31 +NULL_LITERAL=32 +STRING_LITERAL=33 +LineComment=34 +BlockComment=35 +Whitespace=36 +If=37 +Then=38 +Else=39 +Boolean=40 +I8=41 +I16=42 +I32=43 +I64=44 +FP32=45 +FP64=46 +String=47 +Binary=48 +Timestamp=49 +TimestampTZ=50 +Date=51 +Time=52 +IntervalYear=53 +IntervalDay=54 +UUID=55 +Decimal=56 +PrecisionTimestamp=57 +PrecisionTimestampTZ=58 +FixedChar=59 +VarChar=60 +FixedBinary=61 +Struct=62 +NStruct=63 +List=64 +Map=65 +ANY=66 +UserDefined=67 +Bool=68 +Str=69 +VBin=70 +Ts=71 +TsTZ=72 +IYear=73 +IDay=74 +Dec=75 +PTs=76 +PTsTZ=77 +FChar=78 +VChar=79 +FBin=80 +DOUBLE_COLON=81 +IDENTIFIER=82 +O_ANGLE_BRACKET=83 +C_ANGLE_BRACKET=84 +OPAREN=85 +CPAREN=86 +OBRACKET=87 +CBRACKET=88 +COMMA=89 +EQ=90 +COLON=91 +QMARK=92 +HASH=93 +DOT=94 +'### SUBSTRAIT_SCALAR_TEST:'=1 +'### SUBSTRAIT_INCLUDE:'=3 +''=5 +''=6 +'overlfow'=7 +'rounding'=8 +'ERROR'=9 +'SATURATE'=10 +'SILENT'=11 +'TIE_TO_EVEN'=12 +'NAN'=13 +'P'=22 +'T'=23 +'Y'=24 +'M'=25 +'D'=26 +'H'=27 +'S'=28 +'F'=29 +'null'=32 +'::'=81 +'<'=83 +'>'=84 +'('=85 +')'=86 +'['=87 +']'=88 +','=89 +'='=90 +':'=91 +'?'=92 +'#'=93 +'.'=94 diff --git a/tests/coverage/antlr_parser/TestFileParser.interp b/tests/coverage/antlr_parser/TestFileParser.interp new file mode 100644 index 000000000..9933e9abe --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileParser.interp @@ -0,0 +1,244 @@ +token literal names: +null +'### SUBSTRAIT_SCALAR_TEST:' +null +'### SUBSTRAIT_INCLUDE:' +null +'' +'' +'overlfow' +'rounding' +'ERROR' +'SATURATE' +'SILENT' +'TIE_TO_EVEN' +'NAN' +null +null +null +null +null +null +null +null +'P' +'T' +'Y' +'M' +'D' +'H' +'S' +'F' +null +null +'null' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'::' +null +'<' +'>' +'(' +')' +'[' +']' +',' +'=' +':' +'?' +'#' +'.' + +token symbolic names: +null +SUBSTRAIT_SCALAR_TEST +FORMAT_VERSION +SUBSTRAIT_INCLUDE +DESCRIPTION_LINE +ERROR_RESULT +UNDEFINED_RESULT +OVERFLOW +ROUNDING +ERROR +SATURATE +SILENT +TIE_TO_EVEN +NAN +INTEGER_LITERAL +DECIMAL_LITERAL +FLOAT_LITERAL +BOOLEAN_LITERAL +TIMESTAMP_TZ_LITERAL +TIMESTAMP_LITERAL +TIME_LITERAL +DATE_LITERAL +PERIOD_PREFIX +TIME_PREFIX +YEAR_SUFFIX +M_SUFFIX +DAY_SUFFIX +HOUR_SUFFIX +SECOND_SUFFIX +FRACTIONAL_SECOND_SUFFIX +INTERVAL_YEAR_LITERAL +INTERVAL_DAY_LITERAL +NULL_LITERAL +STRING_LITERAL +LineComment +BlockComment +Whitespace +If +Then +Else +Boolean +I8 +I16 +I32 +I64 +FP32 +FP64 +String +Binary +Timestamp +TimestampTZ +Date +Time +IntervalYear +IntervalDay +UUID +Decimal +PrecisionTimestamp +PrecisionTimestampTZ +FixedChar +VarChar +FixedBinary +Struct +NStruct +List +Map +ANY +UserDefined +Bool +Str +VBin +Ts +TsTZ +IYear +IDay +Dec +PTs +PTsTZ +FChar +VChar +FBin +DOUBLE_COLON +IDENTIFIER +O_ANGLE_BRACKET +C_ANGLE_BRACKET +OPAREN +CPAREN +OBRACKET +CBRACKET +COMMA +EQ +COLON +QMARK +HASH +DOT + +rule names: +doc +header +version +include +testGroupDescription +testCase +testGroup +arguments +result +argument +numericLiteral +nullArg +i8Arg +i16Arg +i32Arg +i64Arg +fp32Arg +fp64Arg +decimalArg +booleanArg +stringArg +dateArg +timeArg +timestampArg +timestampTzArg +intervalYearArg +intervalDayArg +intervalYearLiteral +intervalDayLiteral +timeInterval +datatype +scalarType +fixedCharType +varCharType +fixedBinaryType +decimalType +precisionTimestampType +precisionTimestampTZType +parameterizedType +numericParameter +substraitError +func_option +option_name +option_value +func_options + + +atn: +[4, 1, 94, 395, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 1, 0, 1, 0, 4, 0, 93, 8, 0, 11, 0, 12, 0, 94, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 109, 8, 3, 10, 3, 12, 3, 112, 9, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 124, 8, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 4, 6, 131, 8, 6, 11, 6, 12, 6, 132, 1, 7, 1, 7, 1, 7, 5, 7, 138, 8, 7, 10, 7, 12, 7, 141, 9, 7, 1, 8, 1, 8, 3, 8, 145, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 163, 8, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 237, 8, 27, 1, 27, 1, 27, 1, 27, 3, 27, 242, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 250, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 255, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 261, 8, 29, 1, 29, 1, 29, 3, 29, 265, 8, 29, 1, 29, 1, 29, 3, 29, 269, 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 275, 8, 29, 1, 29, 1, 29, 3, 29, 279, 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 285, 8, 29, 1, 29, 1, 29, 3, 29, 289, 8, 29, 1, 30, 1, 30, 3, 30, 293, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 313, 8, 31, 1, 32, 1, 32, 3, 32, 317, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 3, 33, 325, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 3, 34, 333, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 3, 35, 341, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 349, 8, 35, 1, 36, 1, 36, 3, 36, 353, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 3, 37, 361, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 373, 8, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 5, 44, 390, 8, 44, 10, 44, 12, 44, 393, 9, 44, 1, 44, 0, 0, 45, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 0, 4, 1, 0, 14, 16, 1, 0, 5, 6, 2, 0, 7, 8, 82, 82, 1, 0, 9, 13, 413, 0, 90, 1, 0, 0, 0, 2, 98, 1, 0, 0, 0, 4, 101, 1, 0, 0, 0, 6, 104, 1, 0, 0, 0, 8, 113, 1, 0, 0, 0, 10, 115, 1, 0, 0, 0, 12, 128, 1, 0, 0, 0, 14, 134, 1, 0, 0, 0, 16, 144, 1, 0, 0, 0, 18, 162, 1, 0, 0, 0, 20, 164, 1, 0, 0, 0, 22, 166, 1, 0, 0, 0, 24, 170, 1, 0, 0, 0, 26, 174, 1, 0, 0, 0, 28, 178, 1, 0, 0, 0, 30, 182, 1, 0, 0, 0, 32, 186, 1, 0, 0, 0, 34, 190, 1, 0, 0, 0, 36, 194, 1, 0, 0, 0, 38, 198, 1, 0, 0, 0, 40, 202, 1, 0, 0, 0, 42, 206, 1, 0, 0, 0, 44, 210, 1, 0, 0, 0, 46, 214, 1, 0, 0, 0, 48, 218, 1, 0, 0, 0, 50, 222, 1, 0, 0, 0, 52, 226, 1, 0, 0, 0, 54, 241, 1, 0, 0, 0, 56, 254, 1, 0, 0, 0, 58, 288, 1, 0, 0, 0, 60, 292, 1, 0, 0, 0, 62, 312, 1, 0, 0, 0, 64, 314, 1, 0, 0, 0, 66, 322, 1, 0, 0, 0, 68, 330, 1, 0, 0, 0, 70, 338, 1, 0, 0, 0, 72, 350, 1, 0, 0, 0, 74, 358, 1, 0, 0, 0, 76, 372, 1, 0, 0, 0, 78, 374, 1, 0, 0, 0, 80, 376, 1, 0, 0, 0, 82, 378, 1, 0, 0, 0, 84, 382, 1, 0, 0, 0, 86, 384, 1, 0, 0, 0, 88, 386, 1, 0, 0, 0, 90, 92, 3, 2, 1, 0, 91, 93, 3, 12, 6, 0, 92, 91, 1, 0, 0, 0, 93, 94, 1, 0, 0, 0, 94, 92, 1, 0, 0, 0, 94, 95, 1, 0, 0, 0, 95, 96, 1, 0, 0, 0, 96, 97, 5, 0, 0, 1, 97, 1, 1, 0, 0, 0, 98, 99, 3, 4, 2, 0, 99, 100, 3, 6, 3, 0, 100, 3, 1, 0, 0, 0, 101, 102, 5, 1, 0, 0, 102, 103, 5, 2, 0, 0, 103, 5, 1, 0, 0, 0, 104, 105, 5, 3, 0, 0, 105, 110, 5, 33, 0, 0, 106, 107, 5, 89, 0, 0, 107, 109, 5, 33, 0, 0, 108, 106, 1, 0, 0, 0, 109, 112, 1, 0, 0, 0, 110, 108, 1, 0, 0, 0, 110, 111, 1, 0, 0, 0, 111, 7, 1, 0, 0, 0, 112, 110, 1, 0, 0, 0, 113, 114, 5, 4, 0, 0, 114, 9, 1, 0, 0, 0, 115, 116, 5, 82, 0, 0, 116, 117, 5, 85, 0, 0, 117, 118, 3, 14, 7, 0, 118, 123, 5, 86, 0, 0, 119, 120, 5, 87, 0, 0, 120, 121, 3, 88, 44, 0, 121, 122, 5, 88, 0, 0, 122, 124, 1, 0, 0, 0, 123, 119, 1, 0, 0, 0, 123, 124, 1, 0, 0, 0, 124, 125, 1, 0, 0, 0, 125, 126, 5, 90, 0, 0, 126, 127, 3, 16, 8, 0, 127, 11, 1, 0, 0, 0, 128, 130, 3, 8, 4, 0, 129, 131, 3, 10, 5, 0, 130, 129, 1, 0, 0, 0, 131, 132, 1, 0, 0, 0, 132, 130, 1, 0, 0, 0, 132, 133, 1, 0, 0, 0, 133, 13, 1, 0, 0, 0, 134, 139, 3, 18, 9, 0, 135, 136, 5, 89, 0, 0, 136, 138, 3, 18, 9, 0, 137, 135, 1, 0, 0, 0, 138, 141, 1, 0, 0, 0, 139, 137, 1, 0, 0, 0, 139, 140, 1, 0, 0, 0, 140, 15, 1, 0, 0, 0, 141, 139, 1, 0, 0, 0, 142, 145, 3, 18, 9, 0, 143, 145, 3, 80, 40, 0, 144, 142, 1, 0, 0, 0, 144, 143, 1, 0, 0, 0, 145, 17, 1, 0, 0, 0, 146, 163, 3, 22, 11, 0, 147, 163, 3, 24, 12, 0, 148, 163, 3, 26, 13, 0, 149, 163, 3, 28, 14, 0, 150, 163, 3, 30, 15, 0, 151, 163, 3, 32, 16, 0, 152, 163, 3, 34, 17, 0, 153, 163, 3, 38, 19, 0, 154, 163, 3, 40, 20, 0, 155, 163, 3, 36, 18, 0, 156, 163, 3, 42, 21, 0, 157, 163, 3, 44, 22, 0, 158, 163, 3, 46, 23, 0, 159, 163, 3, 48, 24, 0, 160, 163, 3, 50, 25, 0, 161, 163, 3, 52, 26, 0, 162, 146, 1, 0, 0, 0, 162, 147, 1, 0, 0, 0, 162, 148, 1, 0, 0, 0, 162, 149, 1, 0, 0, 0, 162, 150, 1, 0, 0, 0, 162, 151, 1, 0, 0, 0, 162, 152, 1, 0, 0, 0, 162, 153, 1, 0, 0, 0, 162, 154, 1, 0, 0, 0, 162, 155, 1, 0, 0, 0, 162, 156, 1, 0, 0, 0, 162, 157, 1, 0, 0, 0, 162, 158, 1, 0, 0, 0, 162, 159, 1, 0, 0, 0, 162, 160, 1, 0, 0, 0, 162, 161, 1, 0, 0, 0, 163, 19, 1, 0, 0, 0, 164, 165, 7, 0, 0, 0, 165, 21, 1, 0, 0, 0, 166, 167, 5, 32, 0, 0, 167, 168, 5, 81, 0, 0, 168, 169, 3, 60, 30, 0, 169, 23, 1, 0, 0, 0, 170, 171, 5, 14, 0, 0, 171, 172, 5, 81, 0, 0, 172, 173, 5, 41, 0, 0, 173, 25, 1, 0, 0, 0, 174, 175, 5, 14, 0, 0, 175, 176, 5, 81, 0, 0, 176, 177, 5, 42, 0, 0, 177, 27, 1, 0, 0, 0, 178, 179, 5, 14, 0, 0, 179, 180, 5, 81, 0, 0, 180, 181, 5, 43, 0, 0, 181, 29, 1, 0, 0, 0, 182, 183, 5, 14, 0, 0, 183, 184, 5, 81, 0, 0, 184, 185, 5, 44, 0, 0, 185, 31, 1, 0, 0, 0, 186, 187, 3, 20, 10, 0, 187, 188, 5, 81, 0, 0, 188, 189, 5, 45, 0, 0, 189, 33, 1, 0, 0, 0, 190, 191, 3, 20, 10, 0, 191, 192, 5, 81, 0, 0, 192, 193, 5, 46, 0, 0, 193, 35, 1, 0, 0, 0, 194, 195, 3, 20, 10, 0, 195, 196, 5, 81, 0, 0, 196, 197, 3, 70, 35, 0, 197, 37, 1, 0, 0, 0, 198, 199, 5, 17, 0, 0, 199, 200, 5, 81, 0, 0, 200, 201, 5, 68, 0, 0, 201, 39, 1, 0, 0, 0, 202, 203, 5, 33, 0, 0, 203, 204, 5, 81, 0, 0, 204, 205, 5, 69, 0, 0, 205, 41, 1, 0, 0, 0, 206, 207, 5, 21, 0, 0, 207, 208, 5, 81, 0, 0, 208, 209, 5, 51, 0, 0, 209, 43, 1, 0, 0, 0, 210, 211, 5, 20, 0, 0, 211, 212, 5, 81, 0, 0, 212, 213, 5, 52, 0, 0, 213, 45, 1, 0, 0, 0, 214, 215, 5, 19, 0, 0, 215, 216, 5, 81, 0, 0, 216, 217, 5, 71, 0, 0, 217, 47, 1, 0, 0, 0, 218, 219, 5, 18, 0, 0, 219, 220, 5, 81, 0, 0, 220, 221, 5, 72, 0, 0, 221, 49, 1, 0, 0, 0, 222, 223, 5, 30, 0, 0, 223, 224, 5, 81, 0, 0, 224, 225, 5, 73, 0, 0, 225, 51, 1, 0, 0, 0, 226, 227, 5, 31, 0, 0, 227, 228, 5, 81, 0, 0, 228, 229, 5, 74, 0, 0, 229, 53, 1, 0, 0, 0, 230, 231, 5, 22, 0, 0, 231, 232, 5, 14, 0, 0, 232, 233, 5, 24, 0, 0, 233, 236, 1, 0, 0, 0, 234, 235, 5, 14, 0, 0, 235, 237, 5, 25, 0, 0, 236, 234, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 242, 1, 0, 0, 0, 238, 239, 5, 22, 0, 0, 239, 240, 5, 14, 0, 0, 240, 242, 5, 25, 0, 0, 241, 230, 1, 0, 0, 0, 241, 238, 1, 0, 0, 0, 242, 55, 1, 0, 0, 0, 243, 244, 5, 22, 0, 0, 244, 245, 5, 14, 0, 0, 245, 246, 5, 26, 0, 0, 246, 249, 1, 0, 0, 0, 247, 248, 5, 23, 0, 0, 248, 250, 3, 58, 29, 0, 249, 247, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 255, 1, 0, 0, 0, 251, 252, 5, 22, 0, 0, 252, 253, 5, 23, 0, 0, 253, 255, 3, 58, 29, 0, 254, 243, 1, 0, 0, 0, 254, 251, 1, 0, 0, 0, 255, 57, 1, 0, 0, 0, 256, 257, 5, 14, 0, 0, 257, 260, 5, 27, 0, 0, 258, 259, 5, 14, 0, 0, 259, 261, 5, 25, 0, 0, 260, 258, 1, 0, 0, 0, 260, 261, 1, 0, 0, 0, 261, 264, 1, 0, 0, 0, 262, 263, 5, 14, 0, 0, 263, 265, 5, 28, 0, 0, 264, 262, 1, 0, 0, 0, 264, 265, 1, 0, 0, 0, 265, 268, 1, 0, 0, 0, 266, 267, 5, 14, 0, 0, 267, 269, 5, 29, 0, 0, 268, 266, 1, 0, 0, 0, 268, 269, 1, 0, 0, 0, 269, 289, 1, 0, 0, 0, 270, 271, 5, 14, 0, 0, 271, 274, 5, 25, 0, 0, 272, 273, 5, 14, 0, 0, 273, 275, 5, 28, 0, 0, 274, 272, 1, 0, 0, 0, 274, 275, 1, 0, 0, 0, 275, 278, 1, 0, 0, 0, 276, 277, 5, 14, 0, 0, 277, 279, 5, 29, 0, 0, 278, 276, 1, 0, 0, 0, 278, 279, 1, 0, 0, 0, 279, 289, 1, 0, 0, 0, 280, 281, 5, 14, 0, 0, 281, 284, 5, 28, 0, 0, 282, 283, 5, 14, 0, 0, 283, 285, 5, 29, 0, 0, 284, 282, 1, 0, 0, 0, 284, 285, 1, 0, 0, 0, 285, 289, 1, 0, 0, 0, 286, 287, 5, 14, 0, 0, 287, 289, 5, 29, 0, 0, 288, 256, 1, 0, 0, 0, 288, 270, 1, 0, 0, 0, 288, 280, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 289, 59, 1, 0, 0, 0, 290, 293, 3, 62, 31, 0, 291, 293, 3, 76, 38, 0, 292, 290, 1, 0, 0, 0, 292, 291, 1, 0, 0, 0, 293, 61, 1, 0, 0, 0, 294, 313, 5, 68, 0, 0, 295, 313, 5, 41, 0, 0, 296, 313, 5, 42, 0, 0, 297, 313, 5, 43, 0, 0, 298, 313, 5, 44, 0, 0, 299, 313, 5, 45, 0, 0, 300, 313, 5, 46, 0, 0, 301, 313, 5, 69, 0, 0, 302, 313, 5, 48, 0, 0, 303, 313, 5, 71, 0, 0, 304, 313, 5, 72, 0, 0, 305, 313, 5, 51, 0, 0, 306, 313, 5, 52, 0, 0, 307, 313, 5, 74, 0, 0, 308, 313, 5, 73, 0, 0, 309, 313, 5, 55, 0, 0, 310, 311, 5, 67, 0, 0, 311, 313, 5, 82, 0, 0, 312, 294, 1, 0, 0, 0, 312, 295, 1, 0, 0, 0, 312, 296, 1, 0, 0, 0, 312, 297, 1, 0, 0, 0, 312, 298, 1, 0, 0, 0, 312, 299, 1, 0, 0, 0, 312, 300, 1, 0, 0, 0, 312, 301, 1, 0, 0, 0, 312, 302, 1, 0, 0, 0, 312, 303, 1, 0, 0, 0, 312, 304, 1, 0, 0, 0, 312, 305, 1, 0, 0, 0, 312, 306, 1, 0, 0, 0, 312, 307, 1, 0, 0, 0, 312, 308, 1, 0, 0, 0, 312, 309, 1, 0, 0, 0, 312, 310, 1, 0, 0, 0, 313, 63, 1, 0, 0, 0, 314, 316, 5, 78, 0, 0, 315, 317, 5, 92, 0, 0, 316, 315, 1, 0, 0, 0, 316, 317, 1, 0, 0, 0, 317, 318, 1, 0, 0, 0, 318, 319, 5, 83, 0, 0, 319, 320, 3, 78, 39, 0, 320, 321, 5, 84, 0, 0, 321, 65, 1, 0, 0, 0, 322, 324, 5, 79, 0, 0, 323, 325, 5, 92, 0, 0, 324, 323, 1, 0, 0, 0, 324, 325, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 327, 5, 83, 0, 0, 327, 328, 3, 78, 39, 0, 328, 329, 5, 84, 0, 0, 329, 67, 1, 0, 0, 0, 330, 332, 5, 80, 0, 0, 331, 333, 5, 92, 0, 0, 332, 331, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 334, 1, 0, 0, 0, 334, 335, 5, 83, 0, 0, 335, 336, 3, 78, 39, 0, 336, 337, 5, 84, 0, 0, 337, 69, 1, 0, 0, 0, 338, 340, 5, 75, 0, 0, 339, 341, 5, 92, 0, 0, 340, 339, 1, 0, 0, 0, 340, 341, 1, 0, 0, 0, 341, 348, 1, 0, 0, 0, 342, 343, 5, 83, 0, 0, 343, 344, 3, 78, 39, 0, 344, 345, 5, 89, 0, 0, 345, 346, 3, 78, 39, 0, 346, 347, 5, 84, 0, 0, 347, 349, 1, 0, 0, 0, 348, 342, 1, 0, 0, 0, 348, 349, 1, 0, 0, 0, 349, 71, 1, 0, 0, 0, 350, 352, 5, 76, 0, 0, 351, 353, 5, 92, 0, 0, 352, 351, 1, 0, 0, 0, 352, 353, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 355, 5, 83, 0, 0, 355, 356, 3, 78, 39, 0, 356, 357, 5, 84, 0, 0, 357, 73, 1, 0, 0, 0, 358, 360, 5, 77, 0, 0, 359, 361, 5, 92, 0, 0, 360, 359, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 363, 5, 83, 0, 0, 363, 364, 3, 78, 39, 0, 364, 365, 5, 84, 0, 0, 365, 75, 1, 0, 0, 0, 366, 373, 3, 64, 32, 0, 367, 373, 3, 66, 33, 0, 368, 373, 3, 68, 34, 0, 369, 373, 3, 70, 35, 0, 370, 373, 3, 72, 36, 0, 371, 373, 3, 74, 37, 0, 372, 366, 1, 0, 0, 0, 372, 367, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 372, 369, 1, 0, 0, 0, 372, 370, 1, 0, 0, 0, 372, 371, 1, 0, 0, 0, 373, 77, 1, 0, 0, 0, 374, 375, 5, 14, 0, 0, 375, 79, 1, 0, 0, 0, 376, 377, 7, 1, 0, 0, 377, 81, 1, 0, 0, 0, 378, 379, 3, 84, 42, 0, 379, 380, 5, 91, 0, 0, 380, 381, 3, 86, 43, 0, 381, 83, 1, 0, 0, 0, 382, 383, 7, 2, 0, 0, 383, 85, 1, 0, 0, 0, 384, 385, 7, 3, 0, 0, 385, 87, 1, 0, 0, 0, 386, 391, 3, 82, 41, 0, 387, 388, 5, 89, 0, 0, 388, 390, 3, 82, 41, 0, 389, 387, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 89, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 29, 94, 110, 123, 132, 139, 144, 162, 236, 241, 249, 254, 260, 264, 268, 274, 278, 284, 288, 292, 312, 316, 324, 332, 340, 348, 352, 360, 372, 391] \ No newline at end of file diff --git a/tests/coverage/antlr_parser/TestFileParser.py b/tests/coverage/antlr_parser/TestFileParser.py new file mode 100644 index 000000000..f1d5e70c7 --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileParser.py @@ -0,0 +1,4126 @@ +# Generated from TestFileParser.g4 by ANTLR 4.13.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + +def serializedATN(): + return [ + 4,1,94,395,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, + 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13, + 2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20, + 7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26, + 2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33, + 7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39, + 2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,1,0,1,0,4,0,93, + 8,0,11,0,12,0,94,1,0,1,0,1,1,1,1,1,1,1,2,1,2,1,2,1,3,1,3,1,3,1,3, + 5,3,109,8,3,10,3,12,3,112,9,3,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1, + 5,1,5,3,5,124,8,5,1,5,1,5,1,5,1,6,1,6,4,6,131,8,6,11,6,12,6,132, + 1,7,1,7,1,7,5,7,138,8,7,10,7,12,7,141,9,7,1,8,1,8,3,8,145,8,8,1, + 9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3, + 9,163,8,9,1,10,1,10,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13, + 1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16, + 1,16,1,16,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,19,1,19,1,19, + 1,19,1,20,1,20,1,20,1,20,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22, + 1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,26, + 1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,3,27,237,8,27,1,27, + 1,27,1,27,3,27,242,8,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,250,8, + 28,1,28,1,28,1,28,3,28,255,8,28,1,29,1,29,1,29,1,29,3,29,261,8,29, + 1,29,1,29,3,29,265,8,29,1,29,1,29,3,29,269,8,29,1,29,1,29,1,29,1, + 29,3,29,275,8,29,1,29,1,29,3,29,279,8,29,1,29,1,29,1,29,1,29,3,29, + 285,8,29,1,29,1,29,3,29,289,8,29,1,30,1,30,3,30,293,8,30,1,31,1, + 31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1, + 31,1,31,1,31,1,31,3,31,313,8,31,1,32,1,32,3,32,317,8,32,1,32,1,32, + 1,32,1,32,1,33,1,33,3,33,325,8,33,1,33,1,33,1,33,1,33,1,34,1,34, + 3,34,333,8,34,1,34,1,34,1,34,1,34,1,35,1,35,3,35,341,8,35,1,35,1, + 35,1,35,1,35,1,35,1,35,3,35,349,8,35,1,36,1,36,3,36,353,8,36,1,36, + 1,36,1,36,1,36,1,37,1,37,3,37,361,8,37,1,37,1,37,1,37,1,37,1,38, + 1,38,1,38,1,38,1,38,1,38,3,38,373,8,38,1,39,1,39,1,40,1,40,1,41, + 1,41,1,41,1,41,1,42,1,42,1,43,1,43,1,44,1,44,1,44,5,44,390,8,44, + 10,44,12,44,393,9,44,1,44,0,0,45,0,2,4,6,8,10,12,14,16,18,20,22, + 24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66, + 68,70,72,74,76,78,80,82,84,86,88,0,4,1,0,14,16,1,0,5,6,2,0,7,8,82, + 82,1,0,9,13,413,0,90,1,0,0,0,2,98,1,0,0,0,4,101,1,0,0,0,6,104,1, + 0,0,0,8,113,1,0,0,0,10,115,1,0,0,0,12,128,1,0,0,0,14,134,1,0,0,0, + 16,144,1,0,0,0,18,162,1,0,0,0,20,164,1,0,0,0,22,166,1,0,0,0,24,170, + 1,0,0,0,26,174,1,0,0,0,28,178,1,0,0,0,30,182,1,0,0,0,32,186,1,0, + 0,0,34,190,1,0,0,0,36,194,1,0,0,0,38,198,1,0,0,0,40,202,1,0,0,0, + 42,206,1,0,0,0,44,210,1,0,0,0,46,214,1,0,0,0,48,218,1,0,0,0,50,222, + 1,0,0,0,52,226,1,0,0,0,54,241,1,0,0,0,56,254,1,0,0,0,58,288,1,0, + 0,0,60,292,1,0,0,0,62,312,1,0,0,0,64,314,1,0,0,0,66,322,1,0,0,0, + 68,330,1,0,0,0,70,338,1,0,0,0,72,350,1,0,0,0,74,358,1,0,0,0,76,372, + 1,0,0,0,78,374,1,0,0,0,80,376,1,0,0,0,82,378,1,0,0,0,84,382,1,0, + 0,0,86,384,1,0,0,0,88,386,1,0,0,0,90,92,3,2,1,0,91,93,3,12,6,0,92, + 91,1,0,0,0,93,94,1,0,0,0,94,92,1,0,0,0,94,95,1,0,0,0,95,96,1,0,0, + 0,96,97,5,0,0,1,97,1,1,0,0,0,98,99,3,4,2,0,99,100,3,6,3,0,100,3, + 1,0,0,0,101,102,5,1,0,0,102,103,5,2,0,0,103,5,1,0,0,0,104,105,5, + 3,0,0,105,110,5,33,0,0,106,107,5,89,0,0,107,109,5,33,0,0,108,106, + 1,0,0,0,109,112,1,0,0,0,110,108,1,0,0,0,110,111,1,0,0,0,111,7,1, + 0,0,0,112,110,1,0,0,0,113,114,5,4,0,0,114,9,1,0,0,0,115,116,5,82, + 0,0,116,117,5,85,0,0,117,118,3,14,7,0,118,123,5,86,0,0,119,120,5, + 87,0,0,120,121,3,88,44,0,121,122,5,88,0,0,122,124,1,0,0,0,123,119, + 1,0,0,0,123,124,1,0,0,0,124,125,1,0,0,0,125,126,5,90,0,0,126,127, + 3,16,8,0,127,11,1,0,0,0,128,130,3,8,4,0,129,131,3,10,5,0,130,129, + 1,0,0,0,131,132,1,0,0,0,132,130,1,0,0,0,132,133,1,0,0,0,133,13,1, + 0,0,0,134,139,3,18,9,0,135,136,5,89,0,0,136,138,3,18,9,0,137,135, + 1,0,0,0,138,141,1,0,0,0,139,137,1,0,0,0,139,140,1,0,0,0,140,15,1, + 0,0,0,141,139,1,0,0,0,142,145,3,18,9,0,143,145,3,80,40,0,144,142, + 1,0,0,0,144,143,1,0,0,0,145,17,1,0,0,0,146,163,3,22,11,0,147,163, + 3,24,12,0,148,163,3,26,13,0,149,163,3,28,14,0,150,163,3,30,15,0, + 151,163,3,32,16,0,152,163,3,34,17,0,153,163,3,38,19,0,154,163,3, + 40,20,0,155,163,3,36,18,0,156,163,3,42,21,0,157,163,3,44,22,0,158, + 163,3,46,23,0,159,163,3,48,24,0,160,163,3,50,25,0,161,163,3,52,26, + 0,162,146,1,0,0,0,162,147,1,0,0,0,162,148,1,0,0,0,162,149,1,0,0, + 0,162,150,1,0,0,0,162,151,1,0,0,0,162,152,1,0,0,0,162,153,1,0,0, + 0,162,154,1,0,0,0,162,155,1,0,0,0,162,156,1,0,0,0,162,157,1,0,0, + 0,162,158,1,0,0,0,162,159,1,0,0,0,162,160,1,0,0,0,162,161,1,0,0, + 0,163,19,1,0,0,0,164,165,7,0,0,0,165,21,1,0,0,0,166,167,5,32,0,0, + 167,168,5,81,0,0,168,169,3,60,30,0,169,23,1,0,0,0,170,171,5,14,0, + 0,171,172,5,81,0,0,172,173,5,41,0,0,173,25,1,0,0,0,174,175,5,14, + 0,0,175,176,5,81,0,0,176,177,5,42,0,0,177,27,1,0,0,0,178,179,5,14, + 0,0,179,180,5,81,0,0,180,181,5,43,0,0,181,29,1,0,0,0,182,183,5,14, + 0,0,183,184,5,81,0,0,184,185,5,44,0,0,185,31,1,0,0,0,186,187,3,20, + 10,0,187,188,5,81,0,0,188,189,5,45,0,0,189,33,1,0,0,0,190,191,3, + 20,10,0,191,192,5,81,0,0,192,193,5,46,0,0,193,35,1,0,0,0,194,195, + 3,20,10,0,195,196,5,81,0,0,196,197,3,70,35,0,197,37,1,0,0,0,198, + 199,5,17,0,0,199,200,5,81,0,0,200,201,5,68,0,0,201,39,1,0,0,0,202, + 203,5,33,0,0,203,204,5,81,0,0,204,205,5,69,0,0,205,41,1,0,0,0,206, + 207,5,21,0,0,207,208,5,81,0,0,208,209,5,51,0,0,209,43,1,0,0,0,210, + 211,5,20,0,0,211,212,5,81,0,0,212,213,5,52,0,0,213,45,1,0,0,0,214, + 215,5,19,0,0,215,216,5,81,0,0,216,217,5,71,0,0,217,47,1,0,0,0,218, + 219,5,18,0,0,219,220,5,81,0,0,220,221,5,72,0,0,221,49,1,0,0,0,222, + 223,5,30,0,0,223,224,5,81,0,0,224,225,5,73,0,0,225,51,1,0,0,0,226, + 227,5,31,0,0,227,228,5,81,0,0,228,229,5,74,0,0,229,53,1,0,0,0,230, + 231,5,22,0,0,231,232,5,14,0,0,232,233,5,24,0,0,233,236,1,0,0,0,234, + 235,5,14,0,0,235,237,5,25,0,0,236,234,1,0,0,0,236,237,1,0,0,0,237, + 242,1,0,0,0,238,239,5,22,0,0,239,240,5,14,0,0,240,242,5,25,0,0,241, + 230,1,0,0,0,241,238,1,0,0,0,242,55,1,0,0,0,243,244,5,22,0,0,244, + 245,5,14,0,0,245,246,5,26,0,0,246,249,1,0,0,0,247,248,5,23,0,0,248, + 250,3,58,29,0,249,247,1,0,0,0,249,250,1,0,0,0,250,255,1,0,0,0,251, + 252,5,22,0,0,252,253,5,23,0,0,253,255,3,58,29,0,254,243,1,0,0,0, + 254,251,1,0,0,0,255,57,1,0,0,0,256,257,5,14,0,0,257,260,5,27,0,0, + 258,259,5,14,0,0,259,261,5,25,0,0,260,258,1,0,0,0,260,261,1,0,0, + 0,261,264,1,0,0,0,262,263,5,14,0,0,263,265,5,28,0,0,264,262,1,0, + 0,0,264,265,1,0,0,0,265,268,1,0,0,0,266,267,5,14,0,0,267,269,5,29, + 0,0,268,266,1,0,0,0,268,269,1,0,0,0,269,289,1,0,0,0,270,271,5,14, + 0,0,271,274,5,25,0,0,272,273,5,14,0,0,273,275,5,28,0,0,274,272,1, + 0,0,0,274,275,1,0,0,0,275,278,1,0,0,0,276,277,5,14,0,0,277,279,5, + 29,0,0,278,276,1,0,0,0,278,279,1,0,0,0,279,289,1,0,0,0,280,281,5, + 14,0,0,281,284,5,28,0,0,282,283,5,14,0,0,283,285,5,29,0,0,284,282, + 1,0,0,0,284,285,1,0,0,0,285,289,1,0,0,0,286,287,5,14,0,0,287,289, + 5,29,0,0,288,256,1,0,0,0,288,270,1,0,0,0,288,280,1,0,0,0,288,286, + 1,0,0,0,289,59,1,0,0,0,290,293,3,62,31,0,291,293,3,76,38,0,292,290, + 1,0,0,0,292,291,1,0,0,0,293,61,1,0,0,0,294,313,5,68,0,0,295,313, + 5,41,0,0,296,313,5,42,0,0,297,313,5,43,0,0,298,313,5,44,0,0,299, + 313,5,45,0,0,300,313,5,46,0,0,301,313,5,69,0,0,302,313,5,48,0,0, + 303,313,5,71,0,0,304,313,5,72,0,0,305,313,5,51,0,0,306,313,5,52, + 0,0,307,313,5,74,0,0,308,313,5,73,0,0,309,313,5,55,0,0,310,311,5, + 67,0,0,311,313,5,82,0,0,312,294,1,0,0,0,312,295,1,0,0,0,312,296, + 1,0,0,0,312,297,1,0,0,0,312,298,1,0,0,0,312,299,1,0,0,0,312,300, + 1,0,0,0,312,301,1,0,0,0,312,302,1,0,0,0,312,303,1,0,0,0,312,304, + 1,0,0,0,312,305,1,0,0,0,312,306,1,0,0,0,312,307,1,0,0,0,312,308, + 1,0,0,0,312,309,1,0,0,0,312,310,1,0,0,0,313,63,1,0,0,0,314,316,5, + 78,0,0,315,317,5,92,0,0,316,315,1,0,0,0,316,317,1,0,0,0,317,318, + 1,0,0,0,318,319,5,83,0,0,319,320,3,78,39,0,320,321,5,84,0,0,321, + 65,1,0,0,0,322,324,5,79,0,0,323,325,5,92,0,0,324,323,1,0,0,0,324, + 325,1,0,0,0,325,326,1,0,0,0,326,327,5,83,0,0,327,328,3,78,39,0,328, + 329,5,84,0,0,329,67,1,0,0,0,330,332,5,80,0,0,331,333,5,92,0,0,332, + 331,1,0,0,0,332,333,1,0,0,0,333,334,1,0,0,0,334,335,5,83,0,0,335, + 336,3,78,39,0,336,337,5,84,0,0,337,69,1,0,0,0,338,340,5,75,0,0,339, + 341,5,92,0,0,340,339,1,0,0,0,340,341,1,0,0,0,341,348,1,0,0,0,342, + 343,5,83,0,0,343,344,3,78,39,0,344,345,5,89,0,0,345,346,3,78,39, + 0,346,347,5,84,0,0,347,349,1,0,0,0,348,342,1,0,0,0,348,349,1,0,0, + 0,349,71,1,0,0,0,350,352,5,76,0,0,351,353,5,92,0,0,352,351,1,0,0, + 0,352,353,1,0,0,0,353,354,1,0,0,0,354,355,5,83,0,0,355,356,3,78, + 39,0,356,357,5,84,0,0,357,73,1,0,0,0,358,360,5,77,0,0,359,361,5, + 92,0,0,360,359,1,0,0,0,360,361,1,0,0,0,361,362,1,0,0,0,362,363,5, + 83,0,0,363,364,3,78,39,0,364,365,5,84,0,0,365,75,1,0,0,0,366,373, + 3,64,32,0,367,373,3,66,33,0,368,373,3,68,34,0,369,373,3,70,35,0, + 370,373,3,72,36,0,371,373,3,74,37,0,372,366,1,0,0,0,372,367,1,0, + 0,0,372,368,1,0,0,0,372,369,1,0,0,0,372,370,1,0,0,0,372,371,1,0, + 0,0,373,77,1,0,0,0,374,375,5,14,0,0,375,79,1,0,0,0,376,377,7,1,0, + 0,377,81,1,0,0,0,378,379,3,84,42,0,379,380,5,91,0,0,380,381,3,86, + 43,0,381,83,1,0,0,0,382,383,7,2,0,0,383,85,1,0,0,0,384,385,7,3,0, + 0,385,87,1,0,0,0,386,391,3,82,41,0,387,388,5,89,0,0,388,390,3,82, + 41,0,389,387,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0, + 0,0,392,89,1,0,0,0,393,391,1,0,0,0,29,94,110,123,132,139,144,162, + 236,241,249,254,260,264,268,274,278,284,288,292,312,316,324,332, + 340,348,352,360,372,391 + ] + +class TestFileParser ( Parser ): + + grammarFileName = "TestFileParser.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "'### SUBSTRAIT_SCALAR_TEST:'", "", + "'### SUBSTRAIT_INCLUDE:'", "", "''", + "''", "'overlfow'", "'rounding'", "'ERROR'", + "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", + "", "", "", "", + "", "", "", "", + "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", + "", "", "'null'", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "'::'", "", "'<'", + "'>'", "'('", "')'", "'['", "']'", "','", "'='", "':'", + "'?'", "'#'", "'.'" ] + + symbolicNames = [ "", "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", "DESCRIPTION_LINE", "ERROR_RESULT", + "UNDEFINED_RESULT", "OVERFLOW", "ROUNDING", "ERROR", + "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", + "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", + "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", + "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", "NULL_LITERAL", "STRING_LITERAL", + "LineComment", "BlockComment", "Whitespace", "If", + "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", + "FP32", "FP64", "String", "Binary", "Timestamp", "TimestampTZ", + "Date", "Time", "IntervalYear", "IntervalDay", "UUID", + "Decimal", "PrecisionTimestamp", "PrecisionTimestampTZ", + "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", + "List", "Map", "ANY", "UserDefined", "Bool", "Str", + "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", + "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", + "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", + "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", + "EQ", "COLON", "QMARK", "HASH", "DOT" ] + + RULE_doc = 0 + RULE_header = 1 + RULE_version = 2 + RULE_include = 3 + RULE_testGroupDescription = 4 + RULE_testCase = 5 + RULE_testGroup = 6 + RULE_arguments = 7 + RULE_result = 8 + RULE_argument = 9 + RULE_numericLiteral = 10 + RULE_nullArg = 11 + RULE_i8Arg = 12 + RULE_i16Arg = 13 + RULE_i32Arg = 14 + RULE_i64Arg = 15 + RULE_fp32Arg = 16 + RULE_fp64Arg = 17 + RULE_decimalArg = 18 + RULE_booleanArg = 19 + RULE_stringArg = 20 + RULE_dateArg = 21 + RULE_timeArg = 22 + RULE_timestampArg = 23 + RULE_timestampTzArg = 24 + RULE_intervalYearArg = 25 + RULE_intervalDayArg = 26 + RULE_intervalYearLiteral = 27 + RULE_intervalDayLiteral = 28 + RULE_timeInterval = 29 + RULE_datatype = 30 + RULE_scalarType = 31 + RULE_fixedCharType = 32 + RULE_varCharType = 33 + RULE_fixedBinaryType = 34 + RULE_decimalType = 35 + RULE_precisionTimestampType = 36 + RULE_precisionTimestampTZType = 37 + RULE_parameterizedType = 38 + RULE_numericParameter = 39 + RULE_substraitError = 40 + RULE_func_option = 41 + RULE_option_name = 42 + RULE_option_value = 43 + RULE_func_options = 44 + + ruleNames = [ "doc", "header", "version", "include", "testGroupDescription", + "testCase", "testGroup", "arguments", "result", "argument", + "numericLiteral", "nullArg", "i8Arg", "i16Arg", "i32Arg", + "i64Arg", "fp32Arg", "fp64Arg", "decimalArg", "booleanArg", + "stringArg", "dateArg", "timeArg", "timestampArg", "timestampTzArg", + "intervalYearArg", "intervalDayArg", "intervalYearLiteral", + "intervalDayLiteral", "timeInterval", "datatype", "scalarType", + "fixedCharType", "varCharType", "fixedBinaryType", "decimalType", + "precisionTimestampType", "precisionTimestampTZType", + "parameterizedType", "numericParameter", "substraitError", + "func_option", "option_name", "option_value", "func_options" ] + + EOF = Token.EOF + SUBSTRAIT_SCALAR_TEST=1 + FORMAT_VERSION=2 + SUBSTRAIT_INCLUDE=3 + DESCRIPTION_LINE=4 + ERROR_RESULT=5 + UNDEFINED_RESULT=6 + OVERFLOW=7 + ROUNDING=8 + ERROR=9 + SATURATE=10 + SILENT=11 + TIE_TO_EVEN=12 + NAN=13 + INTEGER_LITERAL=14 + DECIMAL_LITERAL=15 + FLOAT_LITERAL=16 + BOOLEAN_LITERAL=17 + TIMESTAMP_TZ_LITERAL=18 + TIMESTAMP_LITERAL=19 + TIME_LITERAL=20 + DATE_LITERAL=21 + PERIOD_PREFIX=22 + TIME_PREFIX=23 + YEAR_SUFFIX=24 + M_SUFFIX=25 + DAY_SUFFIX=26 + HOUR_SUFFIX=27 + SECOND_SUFFIX=28 + FRACTIONAL_SECOND_SUFFIX=29 + INTERVAL_YEAR_LITERAL=30 + INTERVAL_DAY_LITERAL=31 + NULL_LITERAL=32 + STRING_LITERAL=33 + LineComment=34 + BlockComment=35 + Whitespace=36 + If=37 + Then=38 + Else=39 + Boolean=40 + I8=41 + I16=42 + I32=43 + I64=44 + FP32=45 + FP64=46 + String=47 + Binary=48 + Timestamp=49 + TimestampTZ=50 + Date=51 + Time=52 + IntervalYear=53 + IntervalDay=54 + UUID=55 + Decimal=56 + PrecisionTimestamp=57 + PrecisionTimestampTZ=58 + FixedChar=59 + VarChar=60 + FixedBinary=61 + Struct=62 + NStruct=63 + List=64 + Map=65 + ANY=66 + UserDefined=67 + Bool=68 + Str=69 + VBin=70 + Ts=71 + TsTZ=72 + IYear=73 + IDay=74 + Dec=75 + PTs=76 + PTsTZ=77 + FChar=78 + VChar=79 + FBin=80 + DOUBLE_COLON=81 + IDENTIFIER=82 + O_ANGLE_BRACKET=83 + C_ANGLE_BRACKET=84 + OPAREN=85 + CPAREN=86 + OBRACKET=87 + CBRACKET=88 + COMMA=89 + EQ=90 + COLON=91 + QMARK=92 + HASH=93 + DOT=94 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class DocContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def header(self): + return self.getTypedRuleContext(TestFileParser.HeaderContext,0) + + + def EOF(self): + return self.getToken(TestFileParser.EOF, 0) + + def testGroup(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(TestFileParser.TestGroupContext) + else: + return self.getTypedRuleContext(TestFileParser.TestGroupContext,i) + + + def getRuleIndex(self): + return TestFileParser.RULE_doc + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDoc" ): + listener.enterDoc(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDoc" ): + listener.exitDoc(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDoc" ): + return visitor.visitDoc(self) + else: + return visitor.visitChildren(self) + + + + + def doc(self): + + localctx = TestFileParser.DocContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_doc) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 90 + self.header() + self.state = 92 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 91 + self.testGroup() + self.state = 94 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==4): + break + + self.state = 96 + self.match(TestFileParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class HeaderContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def version(self): + return self.getTypedRuleContext(TestFileParser.VersionContext,0) + + + def include(self): + return self.getTypedRuleContext(TestFileParser.IncludeContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_header + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHeader" ): + listener.enterHeader(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHeader" ): + listener.exitHeader(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHeader" ): + return visitor.visitHeader(self) + else: + return visitor.visitChildren(self) + + + + + def header(self): + + localctx = TestFileParser.HeaderContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_header) + try: + self.enterOuterAlt(localctx, 1) + self.state = 98 + self.version() + self.state = 99 + self.include() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VersionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUBSTRAIT_SCALAR_TEST(self): + return self.getToken(TestFileParser.SUBSTRAIT_SCALAR_TEST, 0) + + def FORMAT_VERSION(self): + return self.getToken(TestFileParser.FORMAT_VERSION, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_version + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVersion" ): + listener.enterVersion(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVersion" ): + listener.exitVersion(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVersion" ): + return visitor.visitVersion(self) + else: + return visitor.visitChildren(self) + + + + + def version(self): + + localctx = TestFileParser.VersionContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_version) + try: + self.enterOuterAlt(localctx, 1) + self.state = 101 + self.match(TestFileParser.SUBSTRAIT_SCALAR_TEST) + self.state = 102 + self.match(TestFileParser.FORMAT_VERSION) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IncludeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUBSTRAIT_INCLUDE(self): + return self.getToken(TestFileParser.SUBSTRAIT_INCLUDE, 0) + + def STRING_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(TestFileParser.STRING_LITERAL) + else: + return self.getToken(TestFileParser.STRING_LITERAL, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(TestFileParser.COMMA) + else: + return self.getToken(TestFileParser.COMMA, i) + + def getRuleIndex(self): + return TestFileParser.RULE_include + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInclude" ): + listener.enterInclude(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInclude" ): + listener.exitInclude(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInclude" ): + return visitor.visitInclude(self) + else: + return visitor.visitChildren(self) + + + + + def include(self): + + localctx = TestFileParser.IncludeContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_include) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 104 + self.match(TestFileParser.SUBSTRAIT_INCLUDE) + self.state = 105 + self.match(TestFileParser.STRING_LITERAL) + self.state = 110 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==89: + self.state = 106 + self.match(TestFileParser.COMMA) + self.state = 107 + self.match(TestFileParser.STRING_LITERAL) + self.state = 112 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TestGroupDescriptionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DESCRIPTION_LINE(self): + return self.getToken(TestFileParser.DESCRIPTION_LINE, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_testGroupDescription + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTestGroupDescription" ): + listener.enterTestGroupDescription(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTestGroupDescription" ): + listener.exitTestGroupDescription(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTestGroupDescription" ): + return visitor.visitTestGroupDescription(self) + else: + return visitor.visitChildren(self) + + + + + def testGroupDescription(self): + + localctx = TestFileParser.TestGroupDescriptionContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_testGroupDescription) + try: + self.enterOuterAlt(localctx, 1) + self.state = 113 + self.match(TestFileParser.DESCRIPTION_LINE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TestCaseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.functionName = None # Token + + def OPAREN(self): + return self.getToken(TestFileParser.OPAREN, 0) + + def arguments(self): + return self.getTypedRuleContext(TestFileParser.ArgumentsContext,0) + + + def CPAREN(self): + return self.getToken(TestFileParser.CPAREN, 0) + + def EQ(self): + return self.getToken(TestFileParser.EQ, 0) + + def result(self): + return self.getTypedRuleContext(TestFileParser.ResultContext,0) + + + def IDENTIFIER(self): + return self.getToken(TestFileParser.IDENTIFIER, 0) + + def OBRACKET(self): + return self.getToken(TestFileParser.OBRACKET, 0) + + def func_options(self): + return self.getTypedRuleContext(TestFileParser.Func_optionsContext,0) + + + def CBRACKET(self): + return self.getToken(TestFileParser.CBRACKET, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_testCase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTestCase" ): + listener.enterTestCase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTestCase" ): + listener.exitTestCase(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTestCase" ): + return visitor.visitTestCase(self) + else: + return visitor.visitChildren(self) + + + + + def testCase(self): + + localctx = TestFileParser.TestCaseContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_testCase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 115 + localctx.functionName = self.match(TestFileParser.IDENTIFIER) + self.state = 116 + self.match(TestFileParser.OPAREN) + self.state = 117 + self.arguments() + self.state = 118 + self.match(TestFileParser.CPAREN) + self.state = 123 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==87: + self.state = 119 + self.match(TestFileParser.OBRACKET) + self.state = 120 + self.func_options() + self.state = 121 + self.match(TestFileParser.CBRACKET) + + + self.state = 125 + self.match(TestFileParser.EQ) + self.state = 126 + self.result() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TestGroupContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def testGroupDescription(self): + return self.getTypedRuleContext(TestFileParser.TestGroupDescriptionContext,0) + + + def testCase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(TestFileParser.TestCaseContext) + else: + return self.getTypedRuleContext(TestFileParser.TestCaseContext,i) + + + def getRuleIndex(self): + return TestFileParser.RULE_testGroup + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTestGroup" ): + listener.enterTestGroup(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTestGroup" ): + listener.exitTestGroup(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTestGroup" ): + return visitor.visitTestGroup(self) + else: + return visitor.visitChildren(self) + + + + + def testGroup(self): + + localctx = TestFileParser.TestGroupContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_testGroup) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 128 + self.testGroupDescription() + self.state = 130 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 129 + self.testCase() + self.state = 132 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==82): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ArgumentsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def argument(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(TestFileParser.ArgumentContext) + else: + return self.getTypedRuleContext(TestFileParser.ArgumentContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(TestFileParser.COMMA) + else: + return self.getToken(TestFileParser.COMMA, i) + + def getRuleIndex(self): + return TestFileParser.RULE_arguments + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArguments" ): + listener.enterArguments(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArguments" ): + listener.exitArguments(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArguments" ): + return visitor.visitArguments(self) + else: + return visitor.visitChildren(self) + + + + + def arguments(self): + + localctx = TestFileParser.ArgumentsContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_arguments) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 134 + self.argument() + self.state = 139 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==89: + self.state = 135 + self.match(TestFileParser.COMMA) + self.state = 136 + self.argument() + self.state = 141 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ResultContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def argument(self): + return self.getTypedRuleContext(TestFileParser.ArgumentContext,0) + + + def substraitError(self): + return self.getTypedRuleContext(TestFileParser.SubstraitErrorContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_result + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterResult" ): + listener.enterResult(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitResult" ): + listener.exitResult(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitResult" ): + return visitor.visitResult(self) + else: + return visitor.visitChildren(self) + + + + + def result(self): + + localctx = TestFileParser.ResultContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_result) + try: + self.state = 144 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [14, 15, 16, 17, 18, 19, 20, 21, 30, 31, 32, 33]: + self.enterOuterAlt(localctx, 1) + self.state = 142 + self.argument() + pass + elif token in [5, 6]: + self.enterOuterAlt(localctx, 2) + self.state = 143 + self.substraitError() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ArgumentContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def nullArg(self): + return self.getTypedRuleContext(TestFileParser.NullArgContext,0) + + + def i8Arg(self): + return self.getTypedRuleContext(TestFileParser.I8ArgContext,0) + + + def i16Arg(self): + return self.getTypedRuleContext(TestFileParser.I16ArgContext,0) + + + def i32Arg(self): + return self.getTypedRuleContext(TestFileParser.I32ArgContext,0) + + + def i64Arg(self): + return self.getTypedRuleContext(TestFileParser.I64ArgContext,0) + + + def fp32Arg(self): + return self.getTypedRuleContext(TestFileParser.Fp32ArgContext,0) + + + def fp64Arg(self): + return self.getTypedRuleContext(TestFileParser.Fp64ArgContext,0) + + + def booleanArg(self): + return self.getTypedRuleContext(TestFileParser.BooleanArgContext,0) + + + def stringArg(self): + return self.getTypedRuleContext(TestFileParser.StringArgContext,0) + + + def decimalArg(self): + return self.getTypedRuleContext(TestFileParser.DecimalArgContext,0) + + + def dateArg(self): + return self.getTypedRuleContext(TestFileParser.DateArgContext,0) + + + def timeArg(self): + return self.getTypedRuleContext(TestFileParser.TimeArgContext,0) + + + def timestampArg(self): + return self.getTypedRuleContext(TestFileParser.TimestampArgContext,0) + + + def timestampTzArg(self): + return self.getTypedRuleContext(TestFileParser.TimestampTzArgContext,0) + + + def intervalYearArg(self): + return self.getTypedRuleContext(TestFileParser.IntervalYearArgContext,0) + + + def intervalDayArg(self): + return self.getTypedRuleContext(TestFileParser.IntervalDayArgContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_argument + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArgument" ): + listener.enterArgument(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArgument" ): + listener.exitArgument(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArgument" ): + return visitor.visitArgument(self) + else: + return visitor.visitChildren(self) + + + + + def argument(self): + + localctx = TestFileParser.ArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_argument) + try: + self.state = 162 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,6,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 146 + self.nullArg() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 147 + self.i8Arg() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 148 + self.i16Arg() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 149 + self.i32Arg() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 150 + self.i64Arg() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 151 + self.fp32Arg() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 152 + self.fp64Arg() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 153 + self.booleanArg() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 154 + self.stringArg() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 155 + self.decimalArg() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 156 + self.dateArg() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 157 + self.timeArg() + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 158 + self.timestampArg() + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 159 + self.timestampTzArg() + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 160 + self.intervalYearArg() + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 161 + self.intervalDayArg() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NumericLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DECIMAL_LITERAL(self): + return self.getToken(TestFileParser.DECIMAL_LITERAL, 0) + + def INTEGER_LITERAL(self): + return self.getToken(TestFileParser.INTEGER_LITERAL, 0) + + def FLOAT_LITERAL(self): + return self.getToken(TestFileParser.FLOAT_LITERAL, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_numericLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNumericLiteral" ): + listener.enterNumericLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNumericLiteral" ): + listener.exitNumericLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNumericLiteral" ): + return visitor.visitNumericLiteral(self) + else: + return visitor.visitChildren(self) + + + + + def numericLiteral(self): + + localctx = TestFileParser.NumericLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_numericLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 164 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 114688) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NullArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NULL_LITERAL(self): + return self.getToken(TestFileParser.NULL_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def datatype(self): + return self.getTypedRuleContext(TestFileParser.DatatypeContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_nullArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNullArg" ): + listener.enterNullArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNullArg" ): + listener.exitNullArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNullArg" ): + return visitor.visitNullArg(self) + else: + return visitor.visitChildren(self) + + + + + def nullArg(self): + + localctx = TestFileParser.NullArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_nullArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 166 + self.match(TestFileParser.NULL_LITERAL) + self.state = 167 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 168 + self.datatype() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I8ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(TestFileParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def I8(self): + return self.getToken(TestFileParser.I8, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_i8Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI8Arg" ): + listener.enterI8Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI8Arg" ): + listener.exitI8Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI8Arg" ): + return visitor.visitI8Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i8Arg(self): + + localctx = TestFileParser.I8ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_i8Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 170 + self.match(TestFileParser.INTEGER_LITERAL) + self.state = 171 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 172 + self.match(TestFileParser.I8) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I16ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(TestFileParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def I16(self): + return self.getToken(TestFileParser.I16, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_i16Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI16Arg" ): + listener.enterI16Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI16Arg" ): + listener.exitI16Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI16Arg" ): + return visitor.visitI16Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i16Arg(self): + + localctx = TestFileParser.I16ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_i16Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 174 + self.match(TestFileParser.INTEGER_LITERAL) + self.state = 175 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 176 + self.match(TestFileParser.I16) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I32ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(TestFileParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def I32(self): + return self.getToken(TestFileParser.I32, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_i32Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI32Arg" ): + listener.enterI32Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI32Arg" ): + listener.exitI32Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI32Arg" ): + return visitor.visitI32Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i32Arg(self): + + localctx = TestFileParser.I32ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_i32Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 178 + self.match(TestFileParser.INTEGER_LITERAL) + self.state = 179 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 180 + self.match(TestFileParser.I32) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I64ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(TestFileParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def I64(self): + return self.getToken(TestFileParser.I64, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_i64Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI64Arg" ): + listener.enterI64Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI64Arg" ): + listener.exitI64Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI64Arg" ): + return visitor.visitI64Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i64Arg(self): + + localctx = TestFileParser.I64ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_i64Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 182 + self.match(TestFileParser.INTEGER_LITERAL) + self.state = 183 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 184 + self.match(TestFileParser.I64) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Fp32ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def numericLiteral(self): + return self.getTypedRuleContext(TestFileParser.NumericLiteralContext,0) + + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def FP32(self): + return self.getToken(TestFileParser.FP32, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_fp32Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp32Arg" ): + listener.enterFp32Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp32Arg" ): + listener.exitFp32Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp32Arg" ): + return visitor.visitFp32Arg(self) + else: + return visitor.visitChildren(self) + + + + + def fp32Arg(self): + + localctx = TestFileParser.Fp32ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_fp32Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 186 + self.numericLiteral() + self.state = 187 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 188 + self.match(TestFileParser.FP32) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Fp64ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def numericLiteral(self): + return self.getTypedRuleContext(TestFileParser.NumericLiteralContext,0) + + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def FP64(self): + return self.getToken(TestFileParser.FP64, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_fp64Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp64Arg" ): + listener.enterFp64Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp64Arg" ): + listener.exitFp64Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp64Arg" ): + return visitor.visitFp64Arg(self) + else: + return visitor.visitChildren(self) + + + + + def fp64Arg(self): + + localctx = TestFileParser.Fp64ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_fp64Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 190 + self.numericLiteral() + self.state = 191 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 192 + self.match(TestFileParser.FP64) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DecimalArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def numericLiteral(self): + return self.getTypedRuleContext(TestFileParser.NumericLiteralContext,0) + + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def decimalType(self): + return self.getTypedRuleContext(TestFileParser.DecimalTypeContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_decimalArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDecimalArg" ): + listener.enterDecimalArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDecimalArg" ): + listener.exitDecimalArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDecimalArg" ): + return visitor.visitDecimalArg(self) + else: + return visitor.visitChildren(self) + + + + + def decimalArg(self): + + localctx = TestFileParser.DecimalArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_decimalArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 194 + self.numericLiteral() + self.state = 195 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 196 + self.decimalType() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BooleanArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BOOLEAN_LITERAL(self): + return self.getToken(TestFileParser.BOOLEAN_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def Bool(self): + return self.getToken(TestFileParser.Bool, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_booleanArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBooleanArg" ): + listener.enterBooleanArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBooleanArg" ): + listener.exitBooleanArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBooleanArg" ): + return visitor.visitBooleanArg(self) + else: + return visitor.visitChildren(self) + + + + + def booleanArg(self): + + localctx = TestFileParser.BooleanArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_booleanArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 198 + self.match(TestFileParser.BOOLEAN_LITERAL) + self.state = 199 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 200 + self.match(TestFileParser.Bool) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StringArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def STRING_LITERAL(self): + return self.getToken(TestFileParser.STRING_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def Str(self): + return self.getToken(TestFileParser.Str, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_stringArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringArg" ): + listener.enterStringArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringArg" ): + listener.exitStringArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitStringArg" ): + return visitor.visitStringArg(self) + else: + return visitor.visitChildren(self) + + + + + def stringArg(self): + + localctx = TestFileParser.StringArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_stringArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 202 + self.match(TestFileParser.STRING_LITERAL) + self.state = 203 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 204 + self.match(TestFileParser.Str) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DateArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DATE_LITERAL(self): + return self.getToken(TestFileParser.DATE_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def Date(self): + return self.getToken(TestFileParser.Date, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_dateArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateArg" ): + listener.enterDateArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateArg" ): + listener.exitDateArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDateArg" ): + return visitor.visitDateArg(self) + else: + return visitor.visitChildren(self) + + + + + def dateArg(self): + + localctx = TestFileParser.DateArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 42, self.RULE_dateArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 206 + self.match(TestFileParser.DATE_LITERAL) + self.state = 207 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 208 + self.match(TestFileParser.Date) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimeArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TIME_LITERAL(self): + return self.getToken(TestFileParser.TIME_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def Time(self): + return self.getToken(TestFileParser.Time, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_timeArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeArg" ): + listener.enterTimeArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeArg" ): + listener.exitTimeArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeArg" ): + return visitor.visitTimeArg(self) + else: + return visitor.visitChildren(self) + + + + + def timeArg(self): + + localctx = TestFileParser.TimeArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 44, self.RULE_timeArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 210 + self.match(TestFileParser.TIME_LITERAL) + self.state = 211 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 212 + self.match(TestFileParser.Time) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimestampArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TIMESTAMP_LITERAL(self): + return self.getToken(TestFileParser.TIMESTAMP_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def Ts(self): + return self.getToken(TestFileParser.Ts, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_timestampArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestampArg" ): + listener.enterTimestampArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestampArg" ): + listener.exitTimestampArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestampArg" ): + return visitor.visitTimestampArg(self) + else: + return visitor.visitChildren(self) + + + + + def timestampArg(self): + + localctx = TestFileParser.TimestampArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 46, self.RULE_timestampArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 214 + self.match(TestFileParser.TIMESTAMP_LITERAL) + self.state = 215 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 216 + self.match(TestFileParser.Ts) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimestampTzArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TIMESTAMP_TZ_LITERAL(self): + return self.getToken(TestFileParser.TIMESTAMP_TZ_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def TsTZ(self): + return self.getToken(TestFileParser.TsTZ, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_timestampTzArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestampTzArg" ): + listener.enterTimestampTzArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestampTzArg" ): + listener.exitTimestampTzArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestampTzArg" ): + return visitor.visitTimestampTzArg(self) + else: + return visitor.visitChildren(self) + + + + + def timestampTzArg(self): + + localctx = TestFileParser.TimestampTzArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_timestampTzArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 218 + self.match(TestFileParser.TIMESTAMP_TZ_LITERAL) + self.state = 219 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 220 + self.match(TestFileParser.TsTZ) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalYearArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTERVAL_YEAR_LITERAL(self): + return self.getToken(TestFileParser.INTERVAL_YEAR_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def IYear(self): + return self.getToken(TestFileParser.IYear, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_intervalYearArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalYearArg" ): + listener.enterIntervalYearArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalYearArg" ): + listener.exitIntervalYearArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalYearArg" ): + return visitor.visitIntervalYearArg(self) + else: + return visitor.visitChildren(self) + + + + + def intervalYearArg(self): + + localctx = TestFileParser.IntervalYearArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 50, self.RULE_intervalYearArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 222 + self.match(TestFileParser.INTERVAL_YEAR_LITERAL) + self.state = 223 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 224 + self.match(TestFileParser.IYear) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalDayArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTERVAL_DAY_LITERAL(self): + return self.getToken(TestFileParser.INTERVAL_DAY_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(TestFileParser.DOUBLE_COLON, 0) + + def IDay(self): + return self.getToken(TestFileParser.IDay, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_intervalDayArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalDayArg" ): + listener.enterIntervalDayArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalDayArg" ): + listener.exitIntervalDayArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalDayArg" ): + return visitor.visitIntervalDayArg(self) + else: + return visitor.visitChildren(self) + + + + + def intervalDayArg(self): + + localctx = TestFileParser.IntervalDayArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 52, self.RULE_intervalDayArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 226 + self.match(TestFileParser.INTERVAL_DAY_LITERAL) + self.state = 227 + self.match(TestFileParser.DOUBLE_COLON) + self.state = 228 + self.match(TestFileParser.IDay) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalYearLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.years = None # Token + self.months = None # Token + + def PERIOD_PREFIX(self): + return self.getToken(TestFileParser.PERIOD_PREFIX, 0) + + def YEAR_SUFFIX(self): + return self.getToken(TestFileParser.YEAR_SUFFIX, 0) + + def INTEGER_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(TestFileParser.INTEGER_LITERAL) + else: + return self.getToken(TestFileParser.INTEGER_LITERAL, i) + + def M_SUFFIX(self): + return self.getToken(TestFileParser.M_SUFFIX, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_intervalYearLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalYearLiteral" ): + listener.enterIntervalYearLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalYearLiteral" ): + listener.exitIntervalYearLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalYearLiteral" ): + return visitor.visitIntervalYearLiteral(self) + else: + return visitor.visitChildren(self) + + + + + def intervalYearLiteral(self): + + localctx = TestFileParser.IntervalYearLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 54, self.RULE_intervalYearLiteral) + self._la = 0 # Token type + try: + self.state = 241 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,8,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 230 + self.match(TestFileParser.PERIOD_PREFIX) + + self.state = 231 + localctx.years = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 232 + self.match(TestFileParser.YEAR_SUFFIX) + self.state = 236 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 234 + localctx.months = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 235 + self.match(TestFileParser.M_SUFFIX) + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 238 + self.match(TestFileParser.PERIOD_PREFIX) + + self.state = 239 + localctx.months = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 240 + self.match(TestFileParser.M_SUFFIX) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalDayLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.days = None # Token + + def PERIOD_PREFIX(self): + return self.getToken(TestFileParser.PERIOD_PREFIX, 0) + + def DAY_SUFFIX(self): + return self.getToken(TestFileParser.DAY_SUFFIX, 0) + + def INTEGER_LITERAL(self): + return self.getToken(TestFileParser.INTEGER_LITERAL, 0) + + def TIME_PREFIX(self): + return self.getToken(TestFileParser.TIME_PREFIX, 0) + + def timeInterval(self): + return self.getTypedRuleContext(TestFileParser.TimeIntervalContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_intervalDayLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalDayLiteral" ): + listener.enterIntervalDayLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalDayLiteral" ): + listener.exitIntervalDayLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalDayLiteral" ): + return visitor.visitIntervalDayLiteral(self) + else: + return visitor.visitChildren(self) + + + + + def intervalDayLiteral(self): + + localctx = TestFileParser.IntervalDayLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_intervalDayLiteral) + self._la = 0 # Token type + try: + self.state = 254 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,10,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 243 + self.match(TestFileParser.PERIOD_PREFIX) + + self.state = 244 + localctx.days = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 245 + self.match(TestFileParser.DAY_SUFFIX) + self.state = 249 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==23: + self.state = 247 + self.match(TestFileParser.TIME_PREFIX) + self.state = 248 + self.timeInterval() + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 251 + self.match(TestFileParser.PERIOD_PREFIX) + self.state = 252 + self.match(TestFileParser.TIME_PREFIX) + self.state = 253 + self.timeInterval() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimeIntervalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.hours = None # Token + self.minutes = None # Token + self.seconds = None # Token + self.fractionalSeconds = None # Token + + def HOUR_SUFFIX(self): + return self.getToken(TestFileParser.HOUR_SUFFIX, 0) + + def INTEGER_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(TestFileParser.INTEGER_LITERAL) + else: + return self.getToken(TestFileParser.INTEGER_LITERAL, i) + + def M_SUFFIX(self): + return self.getToken(TestFileParser.M_SUFFIX, 0) + + def SECOND_SUFFIX(self): + return self.getToken(TestFileParser.SECOND_SUFFIX, 0) + + def FRACTIONAL_SECOND_SUFFIX(self): + return self.getToken(TestFileParser.FRACTIONAL_SECOND_SUFFIX, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_timeInterval + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeInterval" ): + listener.enterTimeInterval(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeInterval" ): + listener.exitTimeInterval(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeInterval" ): + return visitor.visitTimeInterval(self) + else: + return visitor.visitChildren(self) + + + + + def timeInterval(self): + + localctx = TestFileParser.TimeIntervalContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_timeInterval) + self._la = 0 # Token type + try: + self.state = 288 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,17,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 256 + localctx.hours = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 257 + self.match(TestFileParser.HOUR_SUFFIX) + self.state = 260 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,11,self._ctx) + if la_ == 1: + self.state = 258 + localctx.minutes = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 259 + self.match(TestFileParser.M_SUFFIX) + + + self.state = 264 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,12,self._ctx) + if la_ == 1: + self.state = 262 + localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 263 + self.match(TestFileParser.SECOND_SUFFIX) + + + self.state = 268 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 266 + localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 267 + self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 270 + localctx.minutes = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 271 + self.match(TestFileParser.M_SUFFIX) + self.state = 274 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,14,self._ctx) + if la_ == 1: + self.state = 272 + localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 273 + self.match(TestFileParser.SECOND_SUFFIX) + + + self.state = 278 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 276 + localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 277 + self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 280 + localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 281 + self.match(TestFileParser.SECOND_SUFFIX) + self.state = 284 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 282 + localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 283 + self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 286 + localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) + self.state = 287 + self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DatatypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def scalarType(self): + return self.getTypedRuleContext(TestFileParser.ScalarTypeContext,0) + + + def parameterizedType(self): + return self.getTypedRuleContext(TestFileParser.ParameterizedTypeContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_datatype + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDatatype" ): + listener.enterDatatype(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDatatype" ): + listener.exitDatatype(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDatatype" ): + return visitor.visitDatatype(self) + else: + return visitor.visitChildren(self) + + + + + def datatype(self): + + localctx = TestFileParser.DatatypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_datatype) + try: + self.state = 292 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [41, 42, 43, 44, 45, 46, 48, 51, 52, 55, 67, 68, 69, 71, 72, 73, 74]: + self.enterOuterAlt(localctx, 1) + self.state = 290 + self.scalarType() + pass + elif token in [75, 76, 77, 78, 79, 80]: + self.enterOuterAlt(localctx, 2) + self.state = 291 + self.parameterizedType() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScalarTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_scalarType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class DateContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Date(self): + return self.getToken(TestFileParser.Date, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDate" ): + listener.enterDate(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDate" ): + listener.exitDate(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDate" ): + return visitor.visitDate(self) + else: + return visitor.visitChildren(self) + + + class StringContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Str(self): + return self.getToken(TestFileParser.Str, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterString" ): + listener.enterString(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitString" ): + listener.exitString(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitString" ): + return visitor.visitString(self) + else: + return visitor.visitChildren(self) + + + class I64Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I64(self): + return self.getToken(TestFileParser.I64, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI64" ): + listener.enterI64(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI64" ): + listener.exitI64(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI64" ): + return visitor.visitI64(self) + else: + return visitor.visitChildren(self) + + + class UserDefinedContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def UserDefined(self): + return self.getToken(TestFileParser.UserDefined, 0) + def IDENTIFIER(self): + return self.getToken(TestFileParser.IDENTIFIER, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUserDefined" ): + listener.enterUserDefined(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUserDefined" ): + listener.exitUserDefined(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUserDefined" ): + return visitor.visitUserDefined(self) + else: + return visitor.visitChildren(self) + + + class I32Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I32(self): + return self.getToken(TestFileParser.I32, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI32" ): + listener.enterI32(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI32" ): + listener.exitI32(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI32" ): + return visitor.visitI32(self) + else: + return visitor.visitChildren(self) + + + class IntervalYearContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def IYear(self): + return self.getToken(TestFileParser.IYear, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalYear" ): + listener.enterIntervalYear(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalYear" ): + listener.exitIntervalYear(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalYear" ): + return visitor.visitIntervalYear(self) + else: + return visitor.visitChildren(self) + + + class UuidContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def UUID(self): + return self.getToken(TestFileParser.UUID, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUuid" ): + listener.enterUuid(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUuid" ): + listener.exitUuid(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUuid" ): + return visitor.visitUuid(self) + else: + return visitor.visitChildren(self) + + + class I8Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I8(self): + return self.getToken(TestFileParser.I8, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI8" ): + listener.enterI8(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI8" ): + listener.exitI8(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI8" ): + return visitor.visitI8(self) + else: + return visitor.visitChildren(self) + + + class I16Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I16(self): + return self.getToken(TestFileParser.I16, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI16" ): + listener.enterI16(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI16" ): + listener.exitI16(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI16" ): + return visitor.visitI16(self) + else: + return visitor.visitChildren(self) + + + class BinaryContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Binary(self): + return self.getToken(TestFileParser.Binary, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBinary" ): + listener.enterBinary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBinary" ): + listener.exitBinary(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBinary" ): + return visitor.visitBinary(self) + else: + return visitor.visitChildren(self) + + + class IntervalDayContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def IDay(self): + return self.getToken(TestFileParser.IDay, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalDay" ): + listener.enterIntervalDay(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalDay" ): + listener.exitIntervalDay(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalDay" ): + return visitor.visitIntervalDay(self) + else: + return visitor.visitChildren(self) + + + class Fp64Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def FP64(self): + return self.getToken(TestFileParser.FP64, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp64" ): + listener.enterFp64(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp64" ): + listener.exitFp64(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp64" ): + return visitor.visitFp64(self) + else: + return visitor.visitChildren(self) + + + class Fp32Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def FP32(self): + return self.getToken(TestFileParser.FP32, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp32" ): + listener.enterFp32(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp32" ): + listener.exitFp32(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp32" ): + return visitor.visitFp32(self) + else: + return visitor.visitChildren(self) + + + class TimeContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Time(self): + return self.getToken(TestFileParser.Time, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTime" ): + listener.enterTime(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTime" ): + listener.exitTime(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTime" ): + return visitor.visitTime(self) + else: + return visitor.visitChildren(self) + + + class BooleanContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Bool(self): + return self.getToken(TestFileParser.Bool, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBoolean" ): + listener.enterBoolean(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBoolean" ): + listener.exitBoolean(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBoolean" ): + return visitor.visitBoolean(self) + else: + return visitor.visitChildren(self) + + + class TimestampContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Ts(self): + return self.getToken(TestFileParser.Ts, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestamp" ): + listener.enterTimestamp(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestamp" ): + listener.exitTimestamp(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestamp" ): + return visitor.visitTimestamp(self) + else: + return visitor.visitChildren(self) + + + class TimestampTzContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def TsTZ(self): + return self.getToken(TestFileParser.TsTZ, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestampTz" ): + listener.enterTimestampTz(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestampTz" ): + listener.exitTimestampTz(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestampTz" ): + return visitor.visitTimestampTz(self) + else: + return visitor.visitChildren(self) + + + + def scalarType(self): + + localctx = TestFileParser.ScalarTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 62, self.RULE_scalarType) + try: + self.state = 312 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [68]: + localctx = TestFileParser.BooleanContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 294 + self.match(TestFileParser.Bool) + pass + elif token in [41]: + localctx = TestFileParser.I8Context(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 295 + self.match(TestFileParser.I8) + pass + elif token in [42]: + localctx = TestFileParser.I16Context(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 296 + self.match(TestFileParser.I16) + pass + elif token in [43]: + localctx = TestFileParser.I32Context(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 297 + self.match(TestFileParser.I32) + pass + elif token in [44]: + localctx = TestFileParser.I64Context(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 298 + self.match(TestFileParser.I64) + pass + elif token in [45]: + localctx = TestFileParser.Fp32Context(self, localctx) + self.enterOuterAlt(localctx, 6) + self.state = 299 + self.match(TestFileParser.FP32) + pass + elif token in [46]: + localctx = TestFileParser.Fp64Context(self, localctx) + self.enterOuterAlt(localctx, 7) + self.state = 300 + self.match(TestFileParser.FP64) + pass + elif token in [69]: + localctx = TestFileParser.StringContext(self, localctx) + self.enterOuterAlt(localctx, 8) + self.state = 301 + self.match(TestFileParser.Str) + pass + elif token in [48]: + localctx = TestFileParser.BinaryContext(self, localctx) + self.enterOuterAlt(localctx, 9) + self.state = 302 + self.match(TestFileParser.Binary) + pass + elif token in [71]: + localctx = TestFileParser.TimestampContext(self, localctx) + self.enterOuterAlt(localctx, 10) + self.state = 303 + self.match(TestFileParser.Ts) + pass + elif token in [72]: + localctx = TestFileParser.TimestampTzContext(self, localctx) + self.enterOuterAlt(localctx, 11) + self.state = 304 + self.match(TestFileParser.TsTZ) + pass + elif token in [51]: + localctx = TestFileParser.DateContext(self, localctx) + self.enterOuterAlt(localctx, 12) + self.state = 305 + self.match(TestFileParser.Date) + pass + elif token in [52]: + localctx = TestFileParser.TimeContext(self, localctx) + self.enterOuterAlt(localctx, 13) + self.state = 306 + self.match(TestFileParser.Time) + pass + elif token in [74]: + localctx = TestFileParser.IntervalDayContext(self, localctx) + self.enterOuterAlt(localctx, 14) + self.state = 307 + self.match(TestFileParser.IDay) + pass + elif token in [73]: + localctx = TestFileParser.IntervalYearContext(self, localctx) + self.enterOuterAlt(localctx, 15) + self.state = 308 + self.match(TestFileParser.IYear) + pass + elif token in [55]: + localctx = TestFileParser.UuidContext(self, localctx) + self.enterOuterAlt(localctx, 16) + self.state = 309 + self.match(TestFileParser.UUID) + pass + elif token in [67]: + localctx = TestFileParser.UserDefinedContext(self, localctx) + self.enterOuterAlt(localctx, 17) + self.state = 310 + self.match(TestFileParser.UserDefined) + self.state = 311 + self.match(TestFileParser.IDENTIFIER) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FixedCharTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_fixedCharType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class FixedCharContext(FixedCharTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.FixedCharTypeContext + super().__init__(parser) + self.isnull = None # Token + self.len_ = None # NumericParameterContext + self.copyFrom(ctx) + + def FChar(self): + return self.getToken(TestFileParser.FChar, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(TestFileParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFixedChar" ): + listener.enterFixedChar(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFixedChar" ): + listener.exitFixedChar(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFixedChar" ): + return visitor.visitFixedChar(self) + else: + return visitor.visitChildren(self) + + + + def fixedCharType(self): + + localctx = TestFileParser.FixedCharTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 64, self.RULE_fixedCharType) + self._la = 0 # Token type + try: + localctx = TestFileParser.FixedCharContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 314 + self.match(TestFileParser.FChar) + self.state = 316 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==92: + self.state = 315 + localctx.isnull = self.match(TestFileParser.QMARK) + + + self.state = 318 + self.match(TestFileParser.O_ANGLE_BRACKET) + self.state = 319 + localctx.len_ = self.numericParameter() + self.state = 320 + self.match(TestFileParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VarCharTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_varCharType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class VarCharContext(VarCharTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.VarCharTypeContext + super().__init__(parser) + self.isnull = None # Token + self.len_ = None # NumericParameterContext + self.copyFrom(ctx) + + def VChar(self): + return self.getToken(TestFileParser.VChar, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(TestFileParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVarChar" ): + listener.enterVarChar(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVarChar" ): + listener.exitVarChar(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVarChar" ): + return visitor.visitVarChar(self) + else: + return visitor.visitChildren(self) + + + + def varCharType(self): + + localctx = TestFileParser.VarCharTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 66, self.RULE_varCharType) + self._la = 0 # Token type + try: + localctx = TestFileParser.VarCharContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 322 + self.match(TestFileParser.VChar) + self.state = 324 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==92: + self.state = 323 + localctx.isnull = self.match(TestFileParser.QMARK) + + + self.state = 326 + self.match(TestFileParser.O_ANGLE_BRACKET) + self.state = 327 + localctx.len_ = self.numericParameter() + self.state = 328 + self.match(TestFileParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FixedBinaryTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_fixedBinaryType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class FixedBinaryContext(FixedBinaryTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.FixedBinaryTypeContext + super().__init__(parser) + self.isnull = None # Token + self.len_ = None # NumericParameterContext + self.copyFrom(ctx) + + def FBin(self): + return self.getToken(TestFileParser.FBin, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(TestFileParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFixedBinary" ): + listener.enterFixedBinary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFixedBinary" ): + listener.exitFixedBinary(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFixedBinary" ): + return visitor.visitFixedBinary(self) + else: + return visitor.visitChildren(self) + + + + def fixedBinaryType(self): + + localctx = TestFileParser.FixedBinaryTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_fixedBinaryType) + self._la = 0 # Token type + try: + localctx = TestFileParser.FixedBinaryContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 330 + self.match(TestFileParser.FBin) + self.state = 332 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==92: + self.state = 331 + localctx.isnull = self.match(TestFileParser.QMARK) + + + self.state = 334 + self.match(TestFileParser.O_ANGLE_BRACKET) + self.state = 335 + localctx.len_ = self.numericParameter() + self.state = 336 + self.match(TestFileParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DecimalTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_decimalType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class DecimalContext(DecimalTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.DecimalTypeContext + super().__init__(parser) + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.scale = None # NumericParameterContext + self.copyFrom(ctx) + + def Dec(self): + return self.getToken(TestFileParser.Dec, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def COMMA(self): + return self.getToken(TestFileParser.COMMA, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def QMARK(self): + return self.getToken(TestFileParser.QMARK, 0) + def numericParameter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(TestFileParser.NumericParameterContext) + else: + return self.getTypedRuleContext(TestFileParser.NumericParameterContext,i) + + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDecimal" ): + listener.enterDecimal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDecimal" ): + listener.exitDecimal(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDecimal" ): + return visitor.visitDecimal(self) + else: + return visitor.visitChildren(self) + + + + def decimalType(self): + + localctx = TestFileParser.DecimalTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_decimalType) + self._la = 0 # Token type + try: + localctx = TestFileParser.DecimalContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 338 + self.match(TestFileParser.Dec) + self.state = 340 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==92: + self.state = 339 + localctx.isnull = self.match(TestFileParser.QMARK) + + + self.state = 348 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==83: + self.state = 342 + self.match(TestFileParser.O_ANGLE_BRACKET) + self.state = 343 + localctx.precision = self.numericParameter() + self.state = 344 + self.match(TestFileParser.COMMA) + self.state = 345 + localctx.scale = self.numericParameter() + self.state = 346 + self.match(TestFileParser.C_ANGLE_BRACKET) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PrecisionTimestampTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_precisionTimestampType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class PrecisionTimestampContext(PrecisionTimestampTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.PrecisionTimestampTypeContext + super().__init__(parser) + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.copyFrom(ctx) + + def PTs(self): + return self.getToken(TestFileParser.PTs, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(TestFileParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPrecisionTimestamp" ): + listener.enterPrecisionTimestamp(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPrecisionTimestamp" ): + listener.exitPrecisionTimestamp(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPrecisionTimestamp" ): + return visitor.visitPrecisionTimestamp(self) + else: + return visitor.visitChildren(self) + + + + def precisionTimestampType(self): + + localctx = TestFileParser.PrecisionTimestampTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_precisionTimestampType) + self._la = 0 # Token type + try: + localctx = TestFileParser.PrecisionTimestampContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 350 + self.match(TestFileParser.PTs) + self.state = 352 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==92: + self.state = 351 + localctx.isnull = self.match(TestFileParser.QMARK) + + + self.state = 354 + self.match(TestFileParser.O_ANGLE_BRACKET) + self.state = 355 + localctx.precision = self.numericParameter() + self.state = 356 + self.match(TestFileParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PrecisionTimestampTZTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_precisionTimestampTZType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class PrecisionTimestampTZContext(PrecisionTimestampTZTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.PrecisionTimestampTZTypeContext + super().__init__(parser) + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.copyFrom(ctx) + + def PTsTZ(self): + return self.getToken(TestFileParser.PTsTZ, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(TestFileParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPrecisionTimestampTZ" ): + listener.enterPrecisionTimestampTZ(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPrecisionTimestampTZ" ): + listener.exitPrecisionTimestampTZ(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPrecisionTimestampTZ" ): + return visitor.visitPrecisionTimestampTZ(self) + else: + return visitor.visitChildren(self) + + + + def precisionTimestampTZType(self): + + localctx = TestFileParser.PrecisionTimestampTZTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_precisionTimestampTZType) + self._la = 0 # Token type + try: + localctx = TestFileParser.PrecisionTimestampTZContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 358 + self.match(TestFileParser.PTsTZ) + self.state = 360 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==92: + self.state = 359 + localctx.isnull = self.match(TestFileParser.QMARK) + + + self.state = 362 + self.match(TestFileParser.O_ANGLE_BRACKET) + self.state = 363 + localctx.precision = self.numericParameter() + self.state = 364 + self.match(TestFileParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ParameterizedTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fixedCharType(self): + return self.getTypedRuleContext(TestFileParser.FixedCharTypeContext,0) + + + def varCharType(self): + return self.getTypedRuleContext(TestFileParser.VarCharTypeContext,0) + + + def fixedBinaryType(self): + return self.getTypedRuleContext(TestFileParser.FixedBinaryTypeContext,0) + + + def decimalType(self): + return self.getTypedRuleContext(TestFileParser.DecimalTypeContext,0) + + + def precisionTimestampType(self): + return self.getTypedRuleContext(TestFileParser.PrecisionTimestampTypeContext,0) + + + def precisionTimestampTZType(self): + return self.getTypedRuleContext(TestFileParser.PrecisionTimestampTZTypeContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_parameterizedType + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParameterizedType" ): + listener.enterParameterizedType(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParameterizedType" ): + listener.exitParameterizedType(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitParameterizedType" ): + return visitor.visitParameterizedType(self) + else: + return visitor.visitChildren(self) + + + + + def parameterizedType(self): + + localctx = TestFileParser.ParameterizedTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_parameterizedType) + try: + self.state = 372 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [78]: + self.enterOuterAlt(localctx, 1) + self.state = 366 + self.fixedCharType() + pass + elif token in [79]: + self.enterOuterAlt(localctx, 2) + self.state = 367 + self.varCharType() + pass + elif token in [80]: + self.enterOuterAlt(localctx, 3) + self.state = 368 + self.fixedBinaryType() + pass + elif token in [75]: + self.enterOuterAlt(localctx, 4) + self.state = 369 + self.decimalType() + pass + elif token in [76]: + self.enterOuterAlt(localctx, 5) + self.state = 370 + self.precisionTimestampType() + pass + elif token in [77]: + self.enterOuterAlt(localctx, 6) + self.state = 371 + self.precisionTimestampTZType() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NumericParameterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return TestFileParser.RULE_numericParameter + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class IntegerLiteralContext(NumericParameterContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.NumericParameterContext + super().__init__(parser) + self.copyFrom(ctx) + + def INTEGER_LITERAL(self): + return self.getToken(TestFileParser.INTEGER_LITERAL, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntegerLiteral" ): + listener.enterIntegerLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntegerLiteral" ): + listener.exitIntegerLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntegerLiteral" ): + return visitor.visitIntegerLiteral(self) + else: + return visitor.visitChildren(self) + + + + def numericParameter(self): + + localctx = TestFileParser.NumericParameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_numericParameter) + try: + localctx = TestFileParser.IntegerLiteralContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 374 + self.match(TestFileParser.INTEGER_LITERAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SubstraitErrorContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ERROR_RESULT(self): + return self.getToken(TestFileParser.ERROR_RESULT, 0) + + def UNDEFINED_RESULT(self): + return self.getToken(TestFileParser.UNDEFINED_RESULT, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_substraitError + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubstraitError" ): + listener.enterSubstraitError(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubstraitError" ): + listener.exitSubstraitError(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSubstraitError" ): + return visitor.visitSubstraitError(self) + else: + return visitor.visitChildren(self) + + + + + def substraitError(self): + + localctx = TestFileParser.SubstraitErrorContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_substraitError) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 376 + _la = self._input.LA(1) + if not(_la==5 or _la==6): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Func_optionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def option_name(self): + return self.getTypedRuleContext(TestFileParser.Option_nameContext,0) + + + def COLON(self): + return self.getToken(TestFileParser.COLON, 0) + + def option_value(self): + return self.getTypedRuleContext(TestFileParser.Option_valueContext,0) + + + def getRuleIndex(self): + return TestFileParser.RULE_func_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunc_option" ): + listener.enterFunc_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunc_option" ): + listener.exitFunc_option(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFunc_option" ): + return visitor.visitFunc_option(self) + else: + return visitor.visitChildren(self) + + + + + def func_option(self): + + localctx = TestFileParser.Func_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_func_option) + try: + self.enterOuterAlt(localctx, 1) + self.state = 378 + self.option_name() + self.state = 379 + self.match(TestFileParser.COLON) + self.state = 380 + self.option_value() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Option_nameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OVERFLOW(self): + return self.getToken(TestFileParser.OVERFLOW, 0) + + def ROUNDING(self): + return self.getToken(TestFileParser.ROUNDING, 0) + + def IDENTIFIER(self): + return self.getToken(TestFileParser.IDENTIFIER, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_option_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOption_name" ): + listener.enterOption_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOption_name" ): + listener.exitOption_name(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOption_name" ): + return visitor.visitOption_name(self) + else: + return visitor.visitChildren(self) + + + + + def option_name(self): + + localctx = TestFileParser.Option_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_option_name) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 382 + _la = self._input.LA(1) + if not(_la==7 or _la==8 or _la==82): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Option_valueContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ERROR(self): + return self.getToken(TestFileParser.ERROR, 0) + + def SATURATE(self): + return self.getToken(TestFileParser.SATURATE, 0) + + def SILENT(self): + return self.getToken(TestFileParser.SILENT, 0) + + def TIE_TO_EVEN(self): + return self.getToken(TestFileParser.TIE_TO_EVEN, 0) + + def NAN(self): + return self.getToken(TestFileParser.NAN, 0) + + def getRuleIndex(self): + return TestFileParser.RULE_option_value + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOption_value" ): + listener.enterOption_value(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOption_value" ): + listener.exitOption_value(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOption_value" ): + return visitor.visitOption_value(self) + else: + return visitor.visitChildren(self) + + + + + def option_value(self): + + localctx = TestFileParser.Option_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_option_value) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 384 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 15872) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Func_optionsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def func_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(TestFileParser.Func_optionContext) + else: + return self.getTypedRuleContext(TestFileParser.Func_optionContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(TestFileParser.COMMA) + else: + return self.getToken(TestFileParser.COMMA, i) + + def getRuleIndex(self): + return TestFileParser.RULE_func_options + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunc_options" ): + listener.enterFunc_options(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunc_options" ): + listener.exitFunc_options(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFunc_options" ): + return visitor.visitFunc_options(self) + else: + return visitor.visitChildren(self) + + + + + def func_options(self): + + localctx = TestFileParser.Func_optionsContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_func_options) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 386 + self.func_option() + self.state = 391 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==89: + self.state = 387 + self.match(TestFileParser.COMMA) + self.state = 388 + self.func_option() + self.state = 393 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/tests/coverage/antlr_parser/TestFileParser.tokens b/tests/coverage/antlr_parser/TestFileParser.tokens new file mode 100644 index 000000000..a3b65b74e --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileParser.tokens @@ -0,0 +1,127 @@ +SUBSTRAIT_SCALAR_TEST=1 +FORMAT_VERSION=2 +SUBSTRAIT_INCLUDE=3 +DESCRIPTION_LINE=4 +ERROR_RESULT=5 +UNDEFINED_RESULT=6 +OVERFLOW=7 +ROUNDING=8 +ERROR=9 +SATURATE=10 +SILENT=11 +TIE_TO_EVEN=12 +NAN=13 +INTEGER_LITERAL=14 +DECIMAL_LITERAL=15 +FLOAT_LITERAL=16 +BOOLEAN_LITERAL=17 +TIMESTAMP_TZ_LITERAL=18 +TIMESTAMP_LITERAL=19 +TIME_LITERAL=20 +DATE_LITERAL=21 +PERIOD_PREFIX=22 +TIME_PREFIX=23 +YEAR_SUFFIX=24 +M_SUFFIX=25 +DAY_SUFFIX=26 +HOUR_SUFFIX=27 +SECOND_SUFFIX=28 +FRACTIONAL_SECOND_SUFFIX=29 +INTERVAL_YEAR_LITERAL=30 +INTERVAL_DAY_LITERAL=31 +NULL_LITERAL=32 +STRING_LITERAL=33 +LineComment=34 +BlockComment=35 +Whitespace=36 +If=37 +Then=38 +Else=39 +Boolean=40 +I8=41 +I16=42 +I32=43 +I64=44 +FP32=45 +FP64=46 +String=47 +Binary=48 +Timestamp=49 +TimestampTZ=50 +Date=51 +Time=52 +IntervalYear=53 +IntervalDay=54 +UUID=55 +Decimal=56 +PrecisionTimestamp=57 +PrecisionTimestampTZ=58 +FixedChar=59 +VarChar=60 +FixedBinary=61 +Struct=62 +NStruct=63 +List=64 +Map=65 +ANY=66 +UserDefined=67 +Bool=68 +Str=69 +VBin=70 +Ts=71 +TsTZ=72 +IYear=73 +IDay=74 +Dec=75 +PTs=76 +PTsTZ=77 +FChar=78 +VChar=79 +FBin=80 +DOUBLE_COLON=81 +IDENTIFIER=82 +O_ANGLE_BRACKET=83 +C_ANGLE_BRACKET=84 +OPAREN=85 +CPAREN=86 +OBRACKET=87 +CBRACKET=88 +COMMA=89 +EQ=90 +COLON=91 +QMARK=92 +HASH=93 +DOT=94 +'### SUBSTRAIT_SCALAR_TEST:'=1 +'### SUBSTRAIT_INCLUDE:'=3 +''=5 +''=6 +'overlfow'=7 +'rounding'=8 +'ERROR'=9 +'SATURATE'=10 +'SILENT'=11 +'TIE_TO_EVEN'=12 +'NAN'=13 +'P'=22 +'T'=23 +'Y'=24 +'M'=25 +'D'=26 +'H'=27 +'S'=28 +'F'=29 +'null'=32 +'::'=81 +'<'=83 +'>'=84 +'('=85 +')'=86 +'['=87 +']'=88 +','=89 +'='=90 +':'=91 +'?'=92 +'#'=93 +'.'=94 diff --git a/tests/coverage/antlr_parser/TestFileParserListener.py b/tests/coverage/antlr_parser/TestFileParserListener.py new file mode 100644 index 000000000..c419b9f5d --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileParserListener.py @@ -0,0 +1,561 @@ +# Generated from TestFileParser.g4 by ANTLR 4.13.2 +from antlr4 import * +if "." in __name__: + from .TestFileParser import TestFileParser +else: + from TestFileParser import TestFileParser + +# This class defines a complete listener for a parse tree produced by TestFileParser. +class TestFileParserListener(ParseTreeListener): + + # Enter a parse tree produced by TestFileParser#doc. + def enterDoc(self, ctx:TestFileParser.DocContext): + pass + + # Exit a parse tree produced by TestFileParser#doc. + def exitDoc(self, ctx:TestFileParser.DocContext): + pass + + + # Enter a parse tree produced by TestFileParser#header. + def enterHeader(self, ctx:TestFileParser.HeaderContext): + pass + + # Exit a parse tree produced by TestFileParser#header. + def exitHeader(self, ctx:TestFileParser.HeaderContext): + pass + + + # Enter a parse tree produced by TestFileParser#version. + def enterVersion(self, ctx:TestFileParser.VersionContext): + pass + + # Exit a parse tree produced by TestFileParser#version. + def exitVersion(self, ctx:TestFileParser.VersionContext): + pass + + + # Enter a parse tree produced by TestFileParser#include. + def enterInclude(self, ctx:TestFileParser.IncludeContext): + pass + + # Exit a parse tree produced by TestFileParser#include. + def exitInclude(self, ctx:TestFileParser.IncludeContext): + pass + + + # Enter a parse tree produced by TestFileParser#testGroupDescription. + def enterTestGroupDescription(self, ctx:TestFileParser.TestGroupDescriptionContext): + pass + + # Exit a parse tree produced by TestFileParser#testGroupDescription. + def exitTestGroupDescription(self, ctx:TestFileParser.TestGroupDescriptionContext): + pass + + + # Enter a parse tree produced by TestFileParser#testCase. + def enterTestCase(self, ctx:TestFileParser.TestCaseContext): + pass + + # Exit a parse tree produced by TestFileParser#testCase. + def exitTestCase(self, ctx:TestFileParser.TestCaseContext): + pass + + + # Enter a parse tree produced by TestFileParser#testGroup. + def enterTestGroup(self, ctx:TestFileParser.TestGroupContext): + pass + + # Exit a parse tree produced by TestFileParser#testGroup. + def exitTestGroup(self, ctx:TestFileParser.TestGroupContext): + pass + + + # Enter a parse tree produced by TestFileParser#arguments. + def enterArguments(self, ctx:TestFileParser.ArgumentsContext): + pass + + # Exit a parse tree produced by TestFileParser#arguments. + def exitArguments(self, ctx:TestFileParser.ArgumentsContext): + pass + + + # Enter a parse tree produced by TestFileParser#result. + def enterResult(self, ctx:TestFileParser.ResultContext): + pass + + # Exit a parse tree produced by TestFileParser#result. + def exitResult(self, ctx:TestFileParser.ResultContext): + pass + + + # Enter a parse tree produced by TestFileParser#argument. + def enterArgument(self, ctx:TestFileParser.ArgumentContext): + pass + + # Exit a parse tree produced by TestFileParser#argument. + def exitArgument(self, ctx:TestFileParser.ArgumentContext): + pass + + + # Enter a parse tree produced by TestFileParser#numericLiteral. + def enterNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + pass + + # Exit a parse tree produced by TestFileParser#numericLiteral. + def exitNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + pass + + + # Enter a parse tree produced by TestFileParser#nullArg. + def enterNullArg(self, ctx:TestFileParser.NullArgContext): + pass + + # Exit a parse tree produced by TestFileParser#nullArg. + def exitNullArg(self, ctx:TestFileParser.NullArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#i8Arg. + def enterI8Arg(self, ctx:TestFileParser.I8ArgContext): + pass + + # Exit a parse tree produced by TestFileParser#i8Arg. + def exitI8Arg(self, ctx:TestFileParser.I8ArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#i16Arg. + def enterI16Arg(self, ctx:TestFileParser.I16ArgContext): + pass + + # Exit a parse tree produced by TestFileParser#i16Arg. + def exitI16Arg(self, ctx:TestFileParser.I16ArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#i32Arg. + def enterI32Arg(self, ctx:TestFileParser.I32ArgContext): + pass + + # Exit a parse tree produced by TestFileParser#i32Arg. + def exitI32Arg(self, ctx:TestFileParser.I32ArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#i64Arg. + def enterI64Arg(self, ctx:TestFileParser.I64ArgContext): + pass + + # Exit a parse tree produced by TestFileParser#i64Arg. + def exitI64Arg(self, ctx:TestFileParser.I64ArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#fp32Arg. + def enterFp32Arg(self, ctx:TestFileParser.Fp32ArgContext): + pass + + # Exit a parse tree produced by TestFileParser#fp32Arg. + def exitFp32Arg(self, ctx:TestFileParser.Fp32ArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#fp64Arg. + def enterFp64Arg(self, ctx:TestFileParser.Fp64ArgContext): + pass + + # Exit a parse tree produced by TestFileParser#fp64Arg. + def exitFp64Arg(self, ctx:TestFileParser.Fp64ArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#decimalArg. + def enterDecimalArg(self, ctx:TestFileParser.DecimalArgContext): + pass + + # Exit a parse tree produced by TestFileParser#decimalArg. + def exitDecimalArg(self, ctx:TestFileParser.DecimalArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#booleanArg. + def enterBooleanArg(self, ctx:TestFileParser.BooleanArgContext): + pass + + # Exit a parse tree produced by TestFileParser#booleanArg. + def exitBooleanArg(self, ctx:TestFileParser.BooleanArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#stringArg. + def enterStringArg(self, ctx:TestFileParser.StringArgContext): + pass + + # Exit a parse tree produced by TestFileParser#stringArg. + def exitStringArg(self, ctx:TestFileParser.StringArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#dateArg. + def enterDateArg(self, ctx:TestFileParser.DateArgContext): + pass + + # Exit a parse tree produced by TestFileParser#dateArg. + def exitDateArg(self, ctx:TestFileParser.DateArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#timeArg. + def enterTimeArg(self, ctx:TestFileParser.TimeArgContext): + pass + + # Exit a parse tree produced by TestFileParser#timeArg. + def exitTimeArg(self, ctx:TestFileParser.TimeArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#timestampArg. + def enterTimestampArg(self, ctx:TestFileParser.TimestampArgContext): + pass + + # Exit a parse tree produced by TestFileParser#timestampArg. + def exitTimestampArg(self, ctx:TestFileParser.TimestampArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#timestampTzArg. + def enterTimestampTzArg(self, ctx:TestFileParser.TimestampTzArgContext): + pass + + # Exit a parse tree produced by TestFileParser#timestampTzArg. + def exitTimestampTzArg(self, ctx:TestFileParser.TimestampTzArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#intervalYearArg. + def enterIntervalYearArg(self, ctx:TestFileParser.IntervalYearArgContext): + pass + + # Exit a parse tree produced by TestFileParser#intervalYearArg. + def exitIntervalYearArg(self, ctx:TestFileParser.IntervalYearArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#intervalDayArg. + def enterIntervalDayArg(self, ctx:TestFileParser.IntervalDayArgContext): + pass + + # Exit a parse tree produced by TestFileParser#intervalDayArg. + def exitIntervalDayArg(self, ctx:TestFileParser.IntervalDayArgContext): + pass + + + # Enter a parse tree produced by TestFileParser#intervalYearLiteral. + def enterIntervalYearLiteral(self, ctx:TestFileParser.IntervalYearLiteralContext): + pass + + # Exit a parse tree produced by TestFileParser#intervalYearLiteral. + def exitIntervalYearLiteral(self, ctx:TestFileParser.IntervalYearLiteralContext): + pass + + + # Enter a parse tree produced by TestFileParser#intervalDayLiteral. + def enterIntervalDayLiteral(self, ctx:TestFileParser.IntervalDayLiteralContext): + pass + + # Exit a parse tree produced by TestFileParser#intervalDayLiteral. + def exitIntervalDayLiteral(self, ctx:TestFileParser.IntervalDayLiteralContext): + pass + + + # Enter a parse tree produced by TestFileParser#timeInterval. + def enterTimeInterval(self, ctx:TestFileParser.TimeIntervalContext): + pass + + # Exit a parse tree produced by TestFileParser#timeInterval. + def exitTimeInterval(self, ctx:TestFileParser.TimeIntervalContext): + pass + + + # Enter a parse tree produced by TestFileParser#datatype. + def enterDatatype(self, ctx:TestFileParser.DatatypeContext): + pass + + # Exit a parse tree produced by TestFileParser#datatype. + def exitDatatype(self, ctx:TestFileParser.DatatypeContext): + pass + + + # Enter a parse tree produced by TestFileParser#Boolean. + def enterBoolean(self, ctx:TestFileParser.BooleanContext): + pass + + # Exit a parse tree produced by TestFileParser#Boolean. + def exitBoolean(self, ctx:TestFileParser.BooleanContext): + pass + + + # Enter a parse tree produced by TestFileParser#i8. + def enterI8(self, ctx:TestFileParser.I8Context): + pass + + # Exit a parse tree produced by TestFileParser#i8. + def exitI8(self, ctx:TestFileParser.I8Context): + pass + + + # Enter a parse tree produced by TestFileParser#i16. + def enterI16(self, ctx:TestFileParser.I16Context): + pass + + # Exit a parse tree produced by TestFileParser#i16. + def exitI16(self, ctx:TestFileParser.I16Context): + pass + + + # Enter a parse tree produced by TestFileParser#i32. + def enterI32(self, ctx:TestFileParser.I32Context): + pass + + # Exit a parse tree produced by TestFileParser#i32. + def exitI32(self, ctx:TestFileParser.I32Context): + pass + + + # Enter a parse tree produced by TestFileParser#i64. + def enterI64(self, ctx:TestFileParser.I64Context): + pass + + # Exit a parse tree produced by TestFileParser#i64. + def exitI64(self, ctx:TestFileParser.I64Context): + pass + + + # Enter a parse tree produced by TestFileParser#fp32. + def enterFp32(self, ctx:TestFileParser.Fp32Context): + pass + + # Exit a parse tree produced by TestFileParser#fp32. + def exitFp32(self, ctx:TestFileParser.Fp32Context): + pass + + + # Enter a parse tree produced by TestFileParser#fp64. + def enterFp64(self, ctx:TestFileParser.Fp64Context): + pass + + # Exit a parse tree produced by TestFileParser#fp64. + def exitFp64(self, ctx:TestFileParser.Fp64Context): + pass + + + # Enter a parse tree produced by TestFileParser#string. + def enterString(self, ctx:TestFileParser.StringContext): + pass + + # Exit a parse tree produced by TestFileParser#string. + def exitString(self, ctx:TestFileParser.StringContext): + pass + + + # Enter a parse tree produced by TestFileParser#binary. + def enterBinary(self, ctx:TestFileParser.BinaryContext): + pass + + # Exit a parse tree produced by TestFileParser#binary. + def exitBinary(self, ctx:TestFileParser.BinaryContext): + pass + + + # Enter a parse tree produced by TestFileParser#timestamp. + def enterTimestamp(self, ctx:TestFileParser.TimestampContext): + pass + + # Exit a parse tree produced by TestFileParser#timestamp. + def exitTimestamp(self, ctx:TestFileParser.TimestampContext): + pass + + + # Enter a parse tree produced by TestFileParser#timestampTz. + def enterTimestampTz(self, ctx:TestFileParser.TimestampTzContext): + pass + + # Exit a parse tree produced by TestFileParser#timestampTz. + def exitTimestampTz(self, ctx:TestFileParser.TimestampTzContext): + pass + + + # Enter a parse tree produced by TestFileParser#date. + def enterDate(self, ctx:TestFileParser.DateContext): + pass + + # Exit a parse tree produced by TestFileParser#date. + def exitDate(self, ctx:TestFileParser.DateContext): + pass + + + # Enter a parse tree produced by TestFileParser#time. + def enterTime(self, ctx:TestFileParser.TimeContext): + pass + + # Exit a parse tree produced by TestFileParser#time. + def exitTime(self, ctx:TestFileParser.TimeContext): + pass + + + # Enter a parse tree produced by TestFileParser#intervalDay. + def enterIntervalDay(self, ctx:TestFileParser.IntervalDayContext): + pass + + # Exit a parse tree produced by TestFileParser#intervalDay. + def exitIntervalDay(self, ctx:TestFileParser.IntervalDayContext): + pass + + + # Enter a parse tree produced by TestFileParser#intervalYear. + def enterIntervalYear(self, ctx:TestFileParser.IntervalYearContext): + pass + + # Exit a parse tree produced by TestFileParser#intervalYear. + def exitIntervalYear(self, ctx:TestFileParser.IntervalYearContext): + pass + + + # Enter a parse tree produced by TestFileParser#uuid. + def enterUuid(self, ctx:TestFileParser.UuidContext): + pass + + # Exit a parse tree produced by TestFileParser#uuid. + def exitUuid(self, ctx:TestFileParser.UuidContext): + pass + + + # Enter a parse tree produced by TestFileParser#userDefined. + def enterUserDefined(self, ctx:TestFileParser.UserDefinedContext): + pass + + # Exit a parse tree produced by TestFileParser#userDefined. + def exitUserDefined(self, ctx:TestFileParser.UserDefinedContext): + pass + + + # Enter a parse tree produced by TestFileParser#fixedChar. + def enterFixedChar(self, ctx:TestFileParser.FixedCharContext): + pass + + # Exit a parse tree produced by TestFileParser#fixedChar. + def exitFixedChar(self, ctx:TestFileParser.FixedCharContext): + pass + + + # Enter a parse tree produced by TestFileParser#varChar. + def enterVarChar(self, ctx:TestFileParser.VarCharContext): + pass + + # Exit a parse tree produced by TestFileParser#varChar. + def exitVarChar(self, ctx:TestFileParser.VarCharContext): + pass + + + # Enter a parse tree produced by TestFileParser#fixedBinary. + def enterFixedBinary(self, ctx:TestFileParser.FixedBinaryContext): + pass + + # Exit a parse tree produced by TestFileParser#fixedBinary. + def exitFixedBinary(self, ctx:TestFileParser.FixedBinaryContext): + pass + + + # Enter a parse tree produced by TestFileParser#decimal. + def enterDecimal(self, ctx:TestFileParser.DecimalContext): + pass + + # Exit a parse tree produced by TestFileParser#decimal. + def exitDecimal(self, ctx:TestFileParser.DecimalContext): + pass + + + # Enter a parse tree produced by TestFileParser#precisionTimestamp. + def enterPrecisionTimestamp(self, ctx:TestFileParser.PrecisionTimestampContext): + pass + + # Exit a parse tree produced by TestFileParser#precisionTimestamp. + def exitPrecisionTimestamp(self, ctx:TestFileParser.PrecisionTimestampContext): + pass + + + # Enter a parse tree produced by TestFileParser#precisionTimestampTZ. + def enterPrecisionTimestampTZ(self, ctx:TestFileParser.PrecisionTimestampTZContext): + pass + + # Exit a parse tree produced by TestFileParser#precisionTimestampTZ. + def exitPrecisionTimestampTZ(self, ctx:TestFileParser.PrecisionTimestampTZContext): + pass + + + # Enter a parse tree produced by TestFileParser#parameterizedType. + def enterParameterizedType(self, ctx:TestFileParser.ParameterizedTypeContext): + pass + + # Exit a parse tree produced by TestFileParser#parameterizedType. + def exitParameterizedType(self, ctx:TestFileParser.ParameterizedTypeContext): + pass + + + # Enter a parse tree produced by TestFileParser#integerLiteral. + def enterIntegerLiteral(self, ctx:TestFileParser.IntegerLiteralContext): + pass + + # Exit a parse tree produced by TestFileParser#integerLiteral. + def exitIntegerLiteral(self, ctx:TestFileParser.IntegerLiteralContext): + pass + + + # Enter a parse tree produced by TestFileParser#substraitError. + def enterSubstraitError(self, ctx:TestFileParser.SubstraitErrorContext): + pass + + # Exit a parse tree produced by TestFileParser#substraitError. + def exitSubstraitError(self, ctx:TestFileParser.SubstraitErrorContext): + pass + + + # Enter a parse tree produced by TestFileParser#func_option. + def enterFunc_option(self, ctx:TestFileParser.Func_optionContext): + pass + + # Exit a parse tree produced by TestFileParser#func_option. + def exitFunc_option(self, ctx:TestFileParser.Func_optionContext): + pass + + + # Enter a parse tree produced by TestFileParser#option_name. + def enterOption_name(self, ctx:TestFileParser.Option_nameContext): + pass + + # Exit a parse tree produced by TestFileParser#option_name. + def exitOption_name(self, ctx:TestFileParser.Option_nameContext): + pass + + + # Enter a parse tree produced by TestFileParser#option_value. + def enterOption_value(self, ctx:TestFileParser.Option_valueContext): + pass + + # Exit a parse tree produced by TestFileParser#option_value. + def exitOption_value(self, ctx:TestFileParser.Option_valueContext): + pass + + + # Enter a parse tree produced by TestFileParser#func_options. + def enterFunc_options(self, ctx:TestFileParser.Func_optionsContext): + pass + + # Exit a parse tree produced by TestFileParser#func_options. + def exitFunc_options(self, ctx:TestFileParser.Func_optionsContext): + pass + + + +del TestFileParser \ No newline at end of file diff --git a/tests/coverage/antlr_parser/TestFileParserVisitor.py b/tests/coverage/antlr_parser/TestFileParserVisitor.py new file mode 100644 index 000000000..5c7e86f79 --- /dev/null +++ b/tests/coverage/antlr_parser/TestFileParserVisitor.py @@ -0,0 +1,318 @@ +# Generated from TestFileParser.g4 by ANTLR 4.13.2 +from antlr4 import * +if "." in __name__: + from .TestFileParser import TestFileParser +else: + from TestFileParser import TestFileParser + +# This class defines a complete generic visitor for a parse tree produced by TestFileParser. + +class TestFileParserVisitor(ParseTreeVisitor): + + # Visit a parse tree produced by TestFileParser#doc. + def visitDoc(self, ctx:TestFileParser.DocContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#header. + def visitHeader(self, ctx:TestFileParser.HeaderContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#version. + def visitVersion(self, ctx:TestFileParser.VersionContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#include. + def visitInclude(self, ctx:TestFileParser.IncludeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#testGroupDescription. + def visitTestGroupDescription(self, ctx:TestFileParser.TestGroupDescriptionContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#testCase. + def visitTestCase(self, ctx:TestFileParser.TestCaseContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#testGroup. + def visitTestGroup(self, ctx:TestFileParser.TestGroupContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#arguments. + def visitArguments(self, ctx:TestFileParser.ArgumentsContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#result. + def visitResult(self, ctx:TestFileParser.ResultContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#argument. + def visitArgument(self, ctx:TestFileParser.ArgumentContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#numericLiteral. + def visitNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#nullArg. + def visitNullArg(self, ctx:TestFileParser.NullArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i8Arg. + def visitI8Arg(self, ctx:TestFileParser.I8ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i16Arg. + def visitI16Arg(self, ctx:TestFileParser.I16ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i32Arg. + def visitI32Arg(self, ctx:TestFileParser.I32ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i64Arg. + def visitI64Arg(self, ctx:TestFileParser.I64ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#fp32Arg. + def visitFp32Arg(self, ctx:TestFileParser.Fp32ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#fp64Arg. + def visitFp64Arg(self, ctx:TestFileParser.Fp64ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#decimalArg. + def visitDecimalArg(self, ctx:TestFileParser.DecimalArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#booleanArg. + def visitBooleanArg(self, ctx:TestFileParser.BooleanArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#stringArg. + def visitStringArg(self, ctx:TestFileParser.StringArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#dateArg. + def visitDateArg(self, ctx:TestFileParser.DateArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#timeArg. + def visitTimeArg(self, ctx:TestFileParser.TimeArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#timestampArg. + def visitTimestampArg(self, ctx:TestFileParser.TimestampArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#timestampTzArg. + def visitTimestampTzArg(self, ctx:TestFileParser.TimestampTzArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#intervalYearArg. + def visitIntervalYearArg(self, ctx:TestFileParser.IntervalYearArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#intervalDayArg. + def visitIntervalDayArg(self, ctx:TestFileParser.IntervalDayArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#intervalYearLiteral. + def visitIntervalYearLiteral(self, ctx:TestFileParser.IntervalYearLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#intervalDayLiteral. + def visitIntervalDayLiteral(self, ctx:TestFileParser.IntervalDayLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#timeInterval. + def visitTimeInterval(self, ctx:TestFileParser.TimeIntervalContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#datatype. + def visitDatatype(self, ctx:TestFileParser.DatatypeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#Boolean. + def visitBoolean(self, ctx:TestFileParser.BooleanContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i8. + def visitI8(self, ctx:TestFileParser.I8Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i16. + def visitI16(self, ctx:TestFileParser.I16Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i32. + def visitI32(self, ctx:TestFileParser.I32Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#i64. + def visitI64(self, ctx:TestFileParser.I64Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#fp32. + def visitFp32(self, ctx:TestFileParser.Fp32Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#fp64. + def visitFp64(self, ctx:TestFileParser.Fp64Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#string. + def visitString(self, ctx:TestFileParser.StringContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#binary. + def visitBinary(self, ctx:TestFileParser.BinaryContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#timestamp. + def visitTimestamp(self, ctx:TestFileParser.TimestampContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#timestampTz. + def visitTimestampTz(self, ctx:TestFileParser.TimestampTzContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#date. + def visitDate(self, ctx:TestFileParser.DateContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#time. + def visitTime(self, ctx:TestFileParser.TimeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#intervalDay. + def visitIntervalDay(self, ctx:TestFileParser.IntervalDayContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#intervalYear. + def visitIntervalYear(self, ctx:TestFileParser.IntervalYearContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#uuid. + def visitUuid(self, ctx:TestFileParser.UuidContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#userDefined. + def visitUserDefined(self, ctx:TestFileParser.UserDefinedContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#fixedChar. + def visitFixedChar(self, ctx:TestFileParser.FixedCharContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#varChar. + def visitVarChar(self, ctx:TestFileParser.VarCharContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#fixedBinary. + def visitFixedBinary(self, ctx:TestFileParser.FixedBinaryContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#decimal. + def visitDecimal(self, ctx:TestFileParser.DecimalContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#precisionTimestamp. + def visitPrecisionTimestamp(self, ctx:TestFileParser.PrecisionTimestampContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#precisionTimestampTZ. + def visitPrecisionTimestampTZ(self, ctx:TestFileParser.PrecisionTimestampTZContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#parameterizedType. + def visitParameterizedType(self, ctx:TestFileParser.ParameterizedTypeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#integerLiteral. + def visitIntegerLiteral(self, ctx:TestFileParser.IntegerLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#substraitError. + def visitSubstraitError(self, ctx:TestFileParser.SubstraitErrorContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#func_option. + def visitFunc_option(self, ctx:TestFileParser.Func_optionContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#option_name. + def visitOption_name(self, ctx:TestFileParser.Option_nameContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#option_value. + def visitOption_value(self, ctx:TestFileParser.Option_valueContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by TestFileParser#func_options. + def visitFunc_options(self, ctx:TestFileParser.Func_optionsContext): + return self.visitChildren(ctx) + + + +del TestFileParser \ No newline at end of file diff --git a/tests/coverage/case_file_parser.py b/tests/coverage/case_file_parser.py index 68bb82060..132a7ca04 100644 --- a/tests/coverage/case_file_parser.py +++ b/tests/coverage/case_file_parser.py @@ -2,8 +2,8 @@ from antlr4 import CommonTokenStream, FileStream -from tests.coverage.antlr_generated.TestFileLexer import TestFileLexer -from tests.coverage.antlr_generated.TestFileParser import TestFileParser +from tests.coverage.antlr_parser.TestFileLexer import TestFileLexer +from tests.coverage.antlr_parser.TestFileParser import TestFileParser from tests.coverage.visitor import TestCaseVisitor diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index f808cefbf..5bb9fc3e3 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -1,6 +1,6 @@ # SPDX-License-Identifier: Apache-2.0 -from tests.coverage.antlr_generated.TestFileParser import TestFileParser -from tests.coverage.antlr_generated.TestFileParserVisitor import TestFileParserVisitor +from tests.coverage.antlr_parser.TestFileParser import TestFileParser +from tests.coverage.antlr_parser.TestFileParserVisitor import TestFileParserVisitor from tests.coverage.nodes import CaseGroup, TestFile, TestCase, CaseLiteral, SubstraitError From 1f1b6350f718ae20e5d03e759606dd617f021182 Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Tue, 3 Sep 2024 19:31:31 +0530 Subject: [PATCH 08/19] Fix python style-check --- tests/coverage/antlr_parser/SubstraitLexer.py | 5681 ++++++++- tests/coverage/antlr_parser/TestFileLexer.py | 10403 +++++++++++++++- tests/coverage/antlr_parser/TestFileParser.py | 5804 +++++++-- .../antlr_parser/TestFileParserListener.py | 313 +- .../antlr_parser/TestFileParserVisitor.py | 191 +- tests/coverage/coverage.py | 26 +- tests/coverage/extensions.py | 201 +- tests/coverage/nodes.py | 7 +- tests/coverage/test_coverage.py | 31 +- tests/coverage/visitor.py | 61 +- tests/test_extensions.py | 3 +- 11 files changed, 20350 insertions(+), 2371 deletions(-) diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py index bbb0f0de1..2c53bd400 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.py +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -2,6 +2,7 @@ from antlr4 import * from io import StringIO import sys + if sys.version_info[1] > 5: from typing import TextIO else: @@ -10,230 +11,5263 @@ def serializedATN(): return [ - 4,0,61,619,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, - 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, - 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, - 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, - 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, - 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, - 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, - 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, - 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, - 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, - 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, - 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, - 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, - 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,1,0,1,0,1,0,1,0,5,0,184, - 8,0,10,0,12,0,187,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,4,1,196,8,1,11, - 1,12,1,197,1,1,3,1,201,8,1,1,1,5,1,204,8,1,10,1,12,1,207,9,1,1,1, - 1,1,1,1,1,1,1,1,1,2,4,2,215,8,2,11,2,12,2,216,1,2,1,2,1,3,1,3,1, - 4,1,4,1,5,1,5,1,6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10,1,10,1,11,1,11, - 1,12,1,12,1,13,1,13,1,14,1,14,1,15,1,15,1,16,1,16,1,17,1,17,1,18, - 1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1,23,1,23,1,24,1,24, - 1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30,1,30,1,30, - 5,30,278,8,30,10,30,12,30,281,9,30,3,30,283,8,30,1,31,1,31,1,31, - 1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,33,1,34,1,34,1,34, - 1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,36,1,36,1,36,1,36,1,37, - 1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,1,40, - 1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,42,1,42, - 1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43, - 1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,1,47, - 1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47, - 1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48, - 1,49,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50,1,50,1,50,1,50, - 1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51, - 1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,52,1,52,1,52,1,52,1,52,1,52, - 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, - 1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,53, - 1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,55, - 1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56, - 1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,58,1,58,1,58, - 1,58,1,58,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,61,1,61,1,61, - 1,62,1,62,1,62,1,62,1,62,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64, - 1,64,1,65,1,65,1,65,1,66,1,66,1,66,1,66,1,66,1,67,1,67,1,67,1,67, - 1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,69,1,69,1,69,1,69,1,70,1,70, - 1,70,1,70,1,71,1,71,1,71,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72, - 1,72,1,73,1,73,1,73,1,73,1,73,1,73,1,74,1,74,1,74,1,74,1,74,1,75, - 1,75,1,75,1,76,1,76,5,76,591,8,76,10,76,12,76,594,9,76,1,77,1,77, - 1,78,1,78,1,79,1,79,1,80,1,80,1,81,1,81,1,82,1,82,1,83,1,83,1,84, - 1,84,1,85,1,85,1,86,1,86,1,87,1,87,1,88,1,88,0,0,89,1,1,3,2,5,3, - 7,0,9,0,11,0,13,0,15,0,17,0,19,0,21,0,23,0,25,0,27,0,29,0,31,0,33, - 0,35,0,37,0,39,0,41,0,43,0,45,0,47,0,49,0,51,0,53,0,55,0,57,0,59, - 0,61,0,63,4,65,5,67,6,69,7,71,8,73,9,75,10,77,11,79,12,81,13,83, - 14,85,15,87,16,89,17,91,18,93,19,95,20,97,21,99,22,101,23,103,24, - 105,25,107,26,109,27,111,28,113,29,115,30,117,31,119,32,121,33,123, - 34,125,35,127,36,129,37,131,38,133,39,135,40,137,41,139,42,141,43, - 143,44,145,45,147,46,149,47,151,48,153,49,155,50,157,51,159,52,161, - 53,163,54,165,55,167,56,169,57,171,58,173,59,175,60,177,61,1,0,34, - 2,0,10,10,13,13,1,0,42,42,2,0,42,42,47,47,3,0,9,10,13,13,32,32,2, - 0,65,65,97,97,2,0,66,66,98,98,2,0,67,67,99,99,2,0,68,68,100,100, - 2,0,69,69,101,101,2,0,70,70,102,102,2,0,71,71,103,103,2,0,72,72, - 104,104,2,0,73,73,105,105,2,0,74,74,106,106,2,0,75,75,107,107,2, - 0,76,76,108,108,2,0,77,77,109,109,2,0,78,78,110,110,2,0,79,79,111, - 111,2,0,80,80,112,112,2,0,81,81,113,113,2,0,82,82,114,114,2,0,83, - 83,115,115,2,0,84,84,116,116,2,0,85,85,117,117,2,0,86,86,118,118, - 2,0,87,87,119,119,2,0,88,88,120,120,2,0,89,89,121,121,2,0,90,90, - 122,122,1,0,48,57,1,0,49,57,3,0,65,90,95,95,97,122,4,0,48,57,65, - 90,95,95,97,122,598,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,63,1,0, - 0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0, - 0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0, - 0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0, - 0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1, - 0,0,0,0,105,1,0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0, - 113,1,0,0,0,0,115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0, - 0,0,0,123,1,0,0,0,0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131, - 1,0,0,0,0,133,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0, - 0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1, - 0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157,1,0,0,0,0, - 159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0,167,1,0, - 0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0,177, - 1,0,0,0,1,179,1,0,0,0,3,190,1,0,0,0,5,214,1,0,0,0,7,220,1,0,0,0, - 9,222,1,0,0,0,11,224,1,0,0,0,13,226,1,0,0,0,15,228,1,0,0,0,17,230, - 1,0,0,0,19,232,1,0,0,0,21,234,1,0,0,0,23,236,1,0,0,0,25,238,1,0, - 0,0,27,240,1,0,0,0,29,242,1,0,0,0,31,244,1,0,0,0,33,246,1,0,0,0, - 35,248,1,0,0,0,37,250,1,0,0,0,39,252,1,0,0,0,41,254,1,0,0,0,43,256, - 1,0,0,0,45,258,1,0,0,0,47,260,1,0,0,0,49,262,1,0,0,0,51,264,1,0, - 0,0,53,266,1,0,0,0,55,268,1,0,0,0,57,270,1,0,0,0,59,272,1,0,0,0, - 61,282,1,0,0,0,63,284,1,0,0,0,65,287,1,0,0,0,67,292,1,0,0,0,69,297, - 1,0,0,0,71,305,1,0,0,0,73,308,1,0,0,0,75,312,1,0,0,0,77,316,1,0, - 0,0,79,320,1,0,0,0,81,325,1,0,0,0,83,330,1,0,0,0,85,337,1,0,0,0, - 87,344,1,0,0,0,89,354,1,0,0,0,91,367,1,0,0,0,93,372,1,0,0,0,95,377, - 1,0,0,0,97,391,1,0,0,0,99,404,1,0,0,0,101,409,1,0,0,0,103,417,1, - 0,0,0,105,437,1,0,0,0,107,460,1,0,0,0,109,470,1,0,0,0,111,478,1, - 0,0,0,113,490,1,0,0,0,115,497,1,0,0,0,117,505,1,0,0,0,119,510,1, - 0,0,0,121,514,1,0,0,0,123,518,1,0,0,0,125,521,1,0,0,0,127,526,1, - 0,0,0,129,530,1,0,0,0,131,535,1,0,0,0,133,538,1,0,0,0,135,543,1, - 0,0,0,137,549,1,0,0,0,139,554,1,0,0,0,141,558,1,0,0,0,143,562,1, - 0,0,0,145,568,1,0,0,0,147,574,1,0,0,0,149,580,1,0,0,0,151,585,1, - 0,0,0,153,588,1,0,0,0,155,595,1,0,0,0,157,597,1,0,0,0,159,599,1, - 0,0,0,161,601,1,0,0,0,163,603,1,0,0,0,165,605,1,0,0,0,167,607,1, - 0,0,0,169,609,1,0,0,0,171,611,1,0,0,0,173,613,1,0,0,0,175,615,1, - 0,0,0,177,617,1,0,0,0,179,180,5,47,0,0,180,181,5,47,0,0,181,185, - 1,0,0,0,182,184,8,0,0,0,183,182,1,0,0,0,184,187,1,0,0,0,185,183, - 1,0,0,0,185,186,1,0,0,0,186,188,1,0,0,0,187,185,1,0,0,0,188,189, - 6,0,0,0,189,2,1,0,0,0,190,191,5,47,0,0,191,192,5,42,0,0,192,200, - 1,0,0,0,193,201,8,1,0,0,194,196,5,42,0,0,195,194,1,0,0,0,196,197, - 1,0,0,0,197,195,1,0,0,0,197,198,1,0,0,0,198,199,1,0,0,0,199,201, - 8,2,0,0,200,193,1,0,0,0,200,195,1,0,0,0,201,205,1,0,0,0,202,204, - 5,42,0,0,203,202,1,0,0,0,204,207,1,0,0,0,205,203,1,0,0,0,205,206, - 1,0,0,0,206,208,1,0,0,0,207,205,1,0,0,0,208,209,5,42,0,0,209,210, - 5,47,0,0,210,211,1,0,0,0,211,212,6,1,0,0,212,4,1,0,0,0,213,215,7, - 3,0,0,214,213,1,0,0,0,215,216,1,0,0,0,216,214,1,0,0,0,216,217,1, - 0,0,0,217,218,1,0,0,0,218,219,6,2,0,0,219,6,1,0,0,0,220,221,7,4, - 0,0,221,8,1,0,0,0,222,223,7,5,0,0,223,10,1,0,0,0,224,225,7,6,0,0, - 225,12,1,0,0,0,226,227,7,7,0,0,227,14,1,0,0,0,228,229,7,8,0,0,229, - 16,1,0,0,0,230,231,7,9,0,0,231,18,1,0,0,0,232,233,7,10,0,0,233,20, - 1,0,0,0,234,235,7,11,0,0,235,22,1,0,0,0,236,237,7,12,0,0,237,24, - 1,0,0,0,238,239,7,13,0,0,239,26,1,0,0,0,240,241,7,14,0,0,241,28, - 1,0,0,0,242,243,7,15,0,0,243,30,1,0,0,0,244,245,7,16,0,0,245,32, - 1,0,0,0,246,247,7,17,0,0,247,34,1,0,0,0,248,249,7,18,0,0,249,36, - 1,0,0,0,250,251,7,19,0,0,251,38,1,0,0,0,252,253,7,20,0,0,253,40, - 1,0,0,0,254,255,7,21,0,0,255,42,1,0,0,0,256,257,7,22,0,0,257,44, - 1,0,0,0,258,259,7,23,0,0,259,46,1,0,0,0,260,261,7,24,0,0,261,48, - 1,0,0,0,262,263,7,25,0,0,263,50,1,0,0,0,264,265,7,26,0,0,265,52, - 1,0,0,0,266,267,7,27,0,0,267,54,1,0,0,0,268,269,7,28,0,0,269,56, - 1,0,0,0,270,271,7,29,0,0,271,58,1,0,0,0,272,273,7,30,0,0,273,60, - 1,0,0,0,274,283,5,48,0,0,275,279,7,31,0,0,276,278,7,30,0,0,277,276, - 1,0,0,0,278,281,1,0,0,0,279,277,1,0,0,0,279,280,1,0,0,0,280,283, - 1,0,0,0,281,279,1,0,0,0,282,274,1,0,0,0,282,275,1,0,0,0,283,62,1, - 0,0,0,284,285,3,23,11,0,285,286,3,17,8,0,286,64,1,0,0,0,287,288, - 3,45,22,0,288,289,3,21,10,0,289,290,3,15,7,0,290,291,3,33,16,0,291, - 66,1,0,0,0,292,293,3,15,7,0,293,294,3,29,14,0,294,295,3,43,21,0, - 295,296,3,15,7,0,296,68,1,0,0,0,297,298,3,9,4,0,298,299,3,35,17, - 0,299,300,3,35,17,0,300,301,3,29,14,0,301,302,3,15,7,0,302,303,3, - 7,3,0,303,304,3,33,16,0,304,70,1,0,0,0,305,306,3,23,11,0,306,307, - 5,56,0,0,307,72,1,0,0,0,308,309,3,23,11,0,309,310,5,49,0,0,310,311, - 5,54,0,0,311,74,1,0,0,0,312,313,3,23,11,0,313,314,5,51,0,0,314,315, - 5,50,0,0,315,76,1,0,0,0,316,317,3,23,11,0,317,318,5,54,0,0,318,319, - 5,52,0,0,319,78,1,0,0,0,320,321,3,17,8,0,321,322,3,37,18,0,322,323, - 5,51,0,0,323,324,5,50,0,0,324,80,1,0,0,0,325,326,3,17,8,0,326,327, - 3,37,18,0,327,328,5,54,0,0,328,329,5,52,0,0,329,82,1,0,0,0,330,331, - 3,43,21,0,331,332,3,45,22,0,332,333,3,41,20,0,333,334,3,23,11,0, - 334,335,3,33,16,0,335,336,3,19,9,0,336,84,1,0,0,0,337,338,3,9,4, - 0,338,339,3,23,11,0,339,340,3,33,16,0,340,341,3,7,3,0,341,342,3, - 41,20,0,342,343,3,55,27,0,343,86,1,0,0,0,344,345,3,45,22,0,345,346, - 3,23,11,0,346,347,3,31,15,0,347,348,3,15,7,0,348,349,3,43,21,0,349, - 350,3,45,22,0,350,351,3,7,3,0,351,352,3,31,15,0,352,353,3,37,18, - 0,353,88,1,0,0,0,354,355,3,45,22,0,355,356,3,23,11,0,356,357,3,31, - 15,0,357,358,3,15,7,0,358,359,3,43,21,0,359,360,3,45,22,0,360,361, - 3,7,3,0,361,362,3,31,15,0,362,363,3,37,18,0,363,364,5,95,0,0,364, - 365,3,45,22,0,365,366,3,57,28,0,366,90,1,0,0,0,367,368,3,13,6,0, - 368,369,3,7,3,0,369,370,3,45,22,0,370,371,3,15,7,0,371,92,1,0,0, - 0,372,373,3,45,22,0,373,374,3,23,11,0,374,375,3,31,15,0,375,376, - 3,15,7,0,376,94,1,0,0,0,377,378,3,23,11,0,378,379,3,33,16,0,379, - 380,3,45,22,0,380,381,3,15,7,0,381,382,3,41,20,0,382,383,3,49,24, - 0,383,384,3,7,3,0,384,385,3,29,14,0,385,386,5,95,0,0,386,387,3,55, - 27,0,387,388,3,15,7,0,388,389,3,7,3,0,389,390,3,41,20,0,390,96,1, - 0,0,0,391,392,3,23,11,0,392,393,3,33,16,0,393,394,3,45,22,0,394, - 395,3,15,7,0,395,396,3,41,20,0,396,397,3,49,24,0,397,398,3,7,3,0, - 398,399,3,29,14,0,399,400,5,95,0,0,400,401,3,13,6,0,401,402,3,7, - 3,0,402,403,3,55,27,0,403,98,1,0,0,0,404,405,3,47,23,0,405,406,3, - 47,23,0,406,407,3,23,11,0,407,408,3,13,6,0,408,100,1,0,0,0,409,410, - 3,13,6,0,410,411,3,15,7,0,411,412,3,11,5,0,412,413,3,23,11,0,413, - 414,3,31,15,0,414,415,3,7,3,0,415,416,3,29,14,0,416,102,1,0,0,0, - 417,418,3,37,18,0,418,419,3,41,20,0,419,420,3,15,7,0,420,421,3,11, - 5,0,421,422,3,23,11,0,422,423,3,43,21,0,423,424,3,23,11,0,424,425, - 3,35,17,0,425,426,3,33,16,0,426,427,5,95,0,0,427,428,3,45,22,0,428, - 429,3,23,11,0,429,430,3,31,15,0,430,431,3,15,7,0,431,432,3,43,21, - 0,432,433,3,45,22,0,433,434,3,7,3,0,434,435,3,31,15,0,435,436,3, - 37,18,0,436,104,1,0,0,0,437,438,3,37,18,0,438,439,3,41,20,0,439, - 440,3,15,7,0,440,441,3,11,5,0,441,442,3,23,11,0,442,443,3,43,21, - 0,443,444,3,23,11,0,444,445,3,35,17,0,445,446,3,33,16,0,446,447, - 5,95,0,0,447,448,3,45,22,0,448,449,3,23,11,0,449,450,3,31,15,0,450, - 451,3,15,7,0,451,452,3,43,21,0,452,453,3,45,22,0,453,454,3,7,3,0, - 454,455,3,31,15,0,455,456,3,37,18,0,456,457,5,95,0,0,457,458,3,45, - 22,0,458,459,3,57,28,0,459,106,1,0,0,0,460,461,3,17,8,0,461,462, - 3,23,11,0,462,463,3,53,26,0,463,464,3,15,7,0,464,465,3,13,6,0,465, - 466,3,11,5,0,466,467,3,21,10,0,467,468,3,7,3,0,468,469,3,41,20,0, - 469,108,1,0,0,0,470,471,3,49,24,0,471,472,3,7,3,0,472,473,3,41,20, - 0,473,474,3,11,5,0,474,475,3,21,10,0,475,476,3,7,3,0,476,477,3,41, - 20,0,477,110,1,0,0,0,478,479,3,17,8,0,479,480,3,23,11,0,480,481, - 3,53,26,0,481,482,3,15,7,0,482,483,3,13,6,0,483,484,3,9,4,0,484, - 485,3,23,11,0,485,486,3,33,16,0,486,487,3,7,3,0,487,488,3,41,20, - 0,488,489,3,55,27,0,489,112,1,0,0,0,490,491,3,43,21,0,491,492,3, - 45,22,0,492,493,3,41,20,0,493,494,3,47,23,0,494,495,3,11,5,0,495, - 496,3,45,22,0,496,114,1,0,0,0,497,498,3,33,16,0,498,499,3,43,21, - 0,499,500,3,45,22,0,500,501,3,41,20,0,501,502,3,47,23,0,502,503, - 3,11,5,0,503,504,3,45,22,0,504,116,1,0,0,0,505,506,3,29,14,0,506, - 507,3,23,11,0,507,508,3,43,21,0,508,509,3,45,22,0,509,118,1,0,0, - 0,510,511,3,31,15,0,511,512,3,7,3,0,512,513,3,37,18,0,513,120,1, - 0,0,0,514,515,3,7,3,0,515,516,3,33,16,0,516,517,3,55,27,0,517,122, - 1,0,0,0,518,519,3,47,23,0,519,520,5,33,0,0,520,124,1,0,0,0,521,522, - 3,9,4,0,522,523,3,35,17,0,523,524,3,35,17,0,524,525,3,29,14,0,525, - 126,1,0,0,0,526,527,3,43,21,0,527,528,3,45,22,0,528,529,3,41,20, - 0,529,128,1,0,0,0,530,531,3,49,24,0,531,532,3,9,4,0,532,533,3,23, - 11,0,533,534,3,33,16,0,534,130,1,0,0,0,535,536,3,45,22,0,536,537, - 3,43,21,0,537,132,1,0,0,0,538,539,3,45,22,0,539,540,3,43,21,0,540, - 541,3,45,22,0,541,542,3,57,28,0,542,134,1,0,0,0,543,544,3,23,11, - 0,544,545,3,55,27,0,545,546,3,15,7,0,546,547,3,7,3,0,547,548,3,41, - 20,0,548,136,1,0,0,0,549,550,3,23,11,0,550,551,3,13,6,0,551,552, - 3,7,3,0,552,553,3,55,27,0,553,138,1,0,0,0,554,555,3,13,6,0,555,556, - 3,15,7,0,556,557,3,11,5,0,557,140,1,0,0,0,558,559,3,37,18,0,559, - 560,3,45,22,0,560,561,3,43,21,0,561,142,1,0,0,0,562,563,3,37,18, - 0,563,564,3,45,22,0,564,565,3,43,21,0,565,566,3,45,22,0,566,567, - 3,57,28,0,567,144,1,0,0,0,568,569,3,17,8,0,569,570,3,11,5,0,570, - 571,3,21,10,0,571,572,3,7,3,0,572,573,3,41,20,0,573,146,1,0,0,0, - 574,575,3,49,24,0,575,576,3,11,5,0,576,577,3,21,10,0,577,578,3,7, - 3,0,578,579,3,41,20,0,579,148,1,0,0,0,580,581,3,17,8,0,581,582,3, - 9,4,0,582,583,3,23,11,0,583,584,3,33,16,0,584,150,1,0,0,0,585,586, - 5,58,0,0,586,587,5,58,0,0,587,152,1,0,0,0,588,592,7,32,0,0,589,591, - 7,33,0,0,590,589,1,0,0,0,591,594,1,0,0,0,592,590,1,0,0,0,592,593, - 1,0,0,0,593,154,1,0,0,0,594,592,1,0,0,0,595,596,5,60,0,0,596,156, - 1,0,0,0,597,598,5,62,0,0,598,158,1,0,0,0,599,600,5,40,0,0,600,160, - 1,0,0,0,601,602,5,41,0,0,602,162,1,0,0,0,603,604,5,91,0,0,604,164, - 1,0,0,0,605,606,5,93,0,0,606,166,1,0,0,0,607,608,5,44,0,0,608,168, - 1,0,0,0,609,610,5,61,0,0,610,170,1,0,0,0,611,612,5,58,0,0,612,172, - 1,0,0,0,613,614,5,63,0,0,614,174,1,0,0,0,615,616,5,35,0,0,616,176, - 1,0,0,0,617,618,5,46,0,0,618,178,1,0,0,0,9,0,185,197,200,205,216, - 279,282,592,1,0,1,0 + 4, + 0, + 61, + 619, + 6, + -1, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 2, + 45, + 7, + 45, + 2, + 46, + 7, + 46, + 2, + 47, + 7, + 47, + 2, + 48, + 7, + 48, + 2, + 49, + 7, + 49, + 2, + 50, + 7, + 50, + 2, + 51, + 7, + 51, + 2, + 52, + 7, + 52, + 2, + 53, + 7, + 53, + 2, + 54, + 7, + 54, + 2, + 55, + 7, + 55, + 2, + 56, + 7, + 56, + 2, + 57, + 7, + 57, + 2, + 58, + 7, + 58, + 2, + 59, + 7, + 59, + 2, + 60, + 7, + 60, + 2, + 61, + 7, + 61, + 2, + 62, + 7, + 62, + 2, + 63, + 7, + 63, + 2, + 64, + 7, + 64, + 2, + 65, + 7, + 65, + 2, + 66, + 7, + 66, + 2, + 67, + 7, + 67, + 2, + 68, + 7, + 68, + 2, + 69, + 7, + 69, + 2, + 70, + 7, + 70, + 2, + 71, + 7, + 71, + 2, + 72, + 7, + 72, + 2, + 73, + 7, + 73, + 2, + 74, + 7, + 74, + 2, + 75, + 7, + 75, + 2, + 76, + 7, + 76, + 2, + 77, + 7, + 77, + 2, + 78, + 7, + 78, + 2, + 79, + 7, + 79, + 2, + 80, + 7, + 80, + 2, + 81, + 7, + 81, + 2, + 82, + 7, + 82, + 2, + 83, + 7, + 83, + 2, + 84, + 7, + 84, + 2, + 85, + 7, + 85, + 2, + 86, + 7, + 86, + 2, + 87, + 7, + 87, + 2, + 88, + 7, + 88, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 5, + 0, + 184, + 8, + 0, + 10, + 0, + 12, + 0, + 187, + 9, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 4, + 1, + 196, + 8, + 1, + 11, + 1, + 12, + 1, + 197, + 1, + 1, + 3, + 1, + 201, + 8, + 1, + 1, + 1, + 5, + 1, + 204, + 8, + 1, + 10, + 1, + 12, + 1, + 207, + 9, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 4, + 2, + 215, + 8, + 2, + 11, + 2, + 12, + 2, + 216, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 1, + 7, + 1, + 7, + 1, + 8, + 1, + 8, + 1, + 9, + 1, + 9, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 13, + 1, + 13, + 1, + 14, + 1, + 14, + 1, + 15, + 1, + 15, + 1, + 16, + 1, + 16, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 30, + 5, + 30, + 278, + 8, + 30, + 10, + 30, + 12, + 30, + 281, + 9, + 30, + 3, + 30, + 283, + 8, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 76, + 1, + 76, + 5, + 76, + 591, + 8, + 76, + 10, + 76, + 12, + 76, + 594, + 9, + 76, + 1, + 77, + 1, + 77, + 1, + 78, + 1, + 78, + 1, + 79, + 1, + 79, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 82, + 1, + 82, + 1, + 83, + 1, + 83, + 1, + 84, + 1, + 84, + 1, + 85, + 1, + 85, + 1, + 86, + 1, + 86, + 1, + 87, + 1, + 87, + 1, + 88, + 1, + 88, + 0, + 0, + 89, + 1, + 1, + 3, + 2, + 5, + 3, + 7, + 0, + 9, + 0, + 11, + 0, + 13, + 0, + 15, + 0, + 17, + 0, + 19, + 0, + 21, + 0, + 23, + 0, + 25, + 0, + 27, + 0, + 29, + 0, + 31, + 0, + 33, + 0, + 35, + 0, + 37, + 0, + 39, + 0, + 41, + 0, + 43, + 0, + 45, + 0, + 47, + 0, + 49, + 0, + 51, + 0, + 53, + 0, + 55, + 0, + 57, + 0, + 59, + 0, + 61, + 0, + 63, + 4, + 65, + 5, + 67, + 6, + 69, + 7, + 71, + 8, + 73, + 9, + 75, + 10, + 77, + 11, + 79, + 12, + 81, + 13, + 83, + 14, + 85, + 15, + 87, + 16, + 89, + 17, + 91, + 18, + 93, + 19, + 95, + 20, + 97, + 21, + 99, + 22, + 101, + 23, + 103, + 24, + 105, + 25, + 107, + 26, + 109, + 27, + 111, + 28, + 113, + 29, + 115, + 30, + 117, + 31, + 119, + 32, + 121, + 33, + 123, + 34, + 125, + 35, + 127, + 36, + 129, + 37, + 131, + 38, + 133, + 39, + 135, + 40, + 137, + 41, + 139, + 42, + 141, + 43, + 143, + 44, + 145, + 45, + 147, + 46, + 149, + 47, + 151, + 48, + 153, + 49, + 155, + 50, + 157, + 51, + 159, + 52, + 161, + 53, + 163, + 54, + 165, + 55, + 167, + 56, + 169, + 57, + 171, + 58, + 173, + 59, + 175, + 60, + 177, + 61, + 1, + 0, + 34, + 2, + 0, + 10, + 10, + 13, + 13, + 1, + 0, + 42, + 42, + 2, + 0, + 42, + 42, + 47, + 47, + 3, + 0, + 9, + 10, + 13, + 13, + 32, + 32, + 2, + 0, + 65, + 65, + 97, + 97, + 2, + 0, + 66, + 66, + 98, + 98, + 2, + 0, + 67, + 67, + 99, + 99, + 2, + 0, + 68, + 68, + 100, + 100, + 2, + 0, + 69, + 69, + 101, + 101, + 2, + 0, + 70, + 70, + 102, + 102, + 2, + 0, + 71, + 71, + 103, + 103, + 2, + 0, + 72, + 72, + 104, + 104, + 2, + 0, + 73, + 73, + 105, + 105, + 2, + 0, + 74, + 74, + 106, + 106, + 2, + 0, + 75, + 75, + 107, + 107, + 2, + 0, + 76, + 76, + 108, + 108, + 2, + 0, + 77, + 77, + 109, + 109, + 2, + 0, + 78, + 78, + 110, + 110, + 2, + 0, + 79, + 79, + 111, + 111, + 2, + 0, + 80, + 80, + 112, + 112, + 2, + 0, + 81, + 81, + 113, + 113, + 2, + 0, + 82, + 82, + 114, + 114, + 2, + 0, + 83, + 83, + 115, + 115, + 2, + 0, + 84, + 84, + 116, + 116, + 2, + 0, + 85, + 85, + 117, + 117, + 2, + 0, + 86, + 86, + 118, + 118, + 2, + 0, + 87, + 87, + 119, + 119, + 2, + 0, + 88, + 88, + 120, + 120, + 2, + 0, + 89, + 89, + 121, + 121, + 2, + 0, + 90, + 90, + 122, + 122, + 1, + 0, + 48, + 57, + 1, + 0, + 49, + 57, + 3, + 0, + 65, + 90, + 95, + 95, + 97, + 122, + 4, + 0, + 48, + 57, + 65, + 90, + 95, + 95, + 97, + 122, + 598, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 5, + 1, + 0, + 0, + 0, + 0, + 63, + 1, + 0, + 0, + 0, + 0, + 65, + 1, + 0, + 0, + 0, + 0, + 67, + 1, + 0, + 0, + 0, + 0, + 69, + 1, + 0, + 0, + 0, + 0, + 71, + 1, + 0, + 0, + 0, + 0, + 73, + 1, + 0, + 0, + 0, + 0, + 75, + 1, + 0, + 0, + 0, + 0, + 77, + 1, + 0, + 0, + 0, + 0, + 79, + 1, + 0, + 0, + 0, + 0, + 81, + 1, + 0, + 0, + 0, + 0, + 83, + 1, + 0, + 0, + 0, + 0, + 85, + 1, + 0, + 0, + 0, + 0, + 87, + 1, + 0, + 0, + 0, + 0, + 89, + 1, + 0, + 0, + 0, + 0, + 91, + 1, + 0, + 0, + 0, + 0, + 93, + 1, + 0, + 0, + 0, + 0, + 95, + 1, + 0, + 0, + 0, + 0, + 97, + 1, + 0, + 0, + 0, + 0, + 99, + 1, + 0, + 0, + 0, + 0, + 101, + 1, + 0, + 0, + 0, + 0, + 103, + 1, + 0, + 0, + 0, + 0, + 105, + 1, + 0, + 0, + 0, + 0, + 107, + 1, + 0, + 0, + 0, + 0, + 109, + 1, + 0, + 0, + 0, + 0, + 111, + 1, + 0, + 0, + 0, + 0, + 113, + 1, + 0, + 0, + 0, + 0, + 115, + 1, + 0, + 0, + 0, + 0, + 117, + 1, + 0, + 0, + 0, + 0, + 119, + 1, + 0, + 0, + 0, + 0, + 121, + 1, + 0, + 0, + 0, + 0, + 123, + 1, + 0, + 0, + 0, + 0, + 125, + 1, + 0, + 0, + 0, + 0, + 127, + 1, + 0, + 0, + 0, + 0, + 129, + 1, + 0, + 0, + 0, + 0, + 131, + 1, + 0, + 0, + 0, + 0, + 133, + 1, + 0, + 0, + 0, + 0, + 135, + 1, + 0, + 0, + 0, + 0, + 137, + 1, + 0, + 0, + 0, + 0, + 139, + 1, + 0, + 0, + 0, + 0, + 141, + 1, + 0, + 0, + 0, + 0, + 143, + 1, + 0, + 0, + 0, + 0, + 145, + 1, + 0, + 0, + 0, + 0, + 147, + 1, + 0, + 0, + 0, + 0, + 149, + 1, + 0, + 0, + 0, + 0, + 151, + 1, + 0, + 0, + 0, + 0, + 153, + 1, + 0, + 0, + 0, + 0, + 155, + 1, + 0, + 0, + 0, + 0, + 157, + 1, + 0, + 0, + 0, + 0, + 159, + 1, + 0, + 0, + 0, + 0, + 161, + 1, + 0, + 0, + 0, + 0, + 163, + 1, + 0, + 0, + 0, + 0, + 165, + 1, + 0, + 0, + 0, + 0, + 167, + 1, + 0, + 0, + 0, + 0, + 169, + 1, + 0, + 0, + 0, + 0, + 171, + 1, + 0, + 0, + 0, + 0, + 173, + 1, + 0, + 0, + 0, + 0, + 175, + 1, + 0, + 0, + 0, + 0, + 177, + 1, + 0, + 0, + 0, + 1, + 179, + 1, + 0, + 0, + 0, + 3, + 190, + 1, + 0, + 0, + 0, + 5, + 214, + 1, + 0, + 0, + 0, + 7, + 220, + 1, + 0, + 0, + 0, + 9, + 222, + 1, + 0, + 0, + 0, + 11, + 224, + 1, + 0, + 0, + 0, + 13, + 226, + 1, + 0, + 0, + 0, + 15, + 228, + 1, + 0, + 0, + 0, + 17, + 230, + 1, + 0, + 0, + 0, + 19, + 232, + 1, + 0, + 0, + 0, + 21, + 234, + 1, + 0, + 0, + 0, + 23, + 236, + 1, + 0, + 0, + 0, + 25, + 238, + 1, + 0, + 0, + 0, + 27, + 240, + 1, + 0, + 0, + 0, + 29, + 242, + 1, + 0, + 0, + 0, + 31, + 244, + 1, + 0, + 0, + 0, + 33, + 246, + 1, + 0, + 0, + 0, + 35, + 248, + 1, + 0, + 0, + 0, + 37, + 250, + 1, + 0, + 0, + 0, + 39, + 252, + 1, + 0, + 0, + 0, + 41, + 254, + 1, + 0, + 0, + 0, + 43, + 256, + 1, + 0, + 0, + 0, + 45, + 258, + 1, + 0, + 0, + 0, + 47, + 260, + 1, + 0, + 0, + 0, + 49, + 262, + 1, + 0, + 0, + 0, + 51, + 264, + 1, + 0, + 0, + 0, + 53, + 266, + 1, + 0, + 0, + 0, + 55, + 268, + 1, + 0, + 0, + 0, + 57, + 270, + 1, + 0, + 0, + 0, + 59, + 272, + 1, + 0, + 0, + 0, + 61, + 282, + 1, + 0, + 0, + 0, + 63, + 284, + 1, + 0, + 0, + 0, + 65, + 287, + 1, + 0, + 0, + 0, + 67, + 292, + 1, + 0, + 0, + 0, + 69, + 297, + 1, + 0, + 0, + 0, + 71, + 305, + 1, + 0, + 0, + 0, + 73, + 308, + 1, + 0, + 0, + 0, + 75, + 312, + 1, + 0, + 0, + 0, + 77, + 316, + 1, + 0, + 0, + 0, + 79, + 320, + 1, + 0, + 0, + 0, + 81, + 325, + 1, + 0, + 0, + 0, + 83, + 330, + 1, + 0, + 0, + 0, + 85, + 337, + 1, + 0, + 0, + 0, + 87, + 344, + 1, + 0, + 0, + 0, + 89, + 354, + 1, + 0, + 0, + 0, + 91, + 367, + 1, + 0, + 0, + 0, + 93, + 372, + 1, + 0, + 0, + 0, + 95, + 377, + 1, + 0, + 0, + 0, + 97, + 391, + 1, + 0, + 0, + 0, + 99, + 404, + 1, + 0, + 0, + 0, + 101, + 409, + 1, + 0, + 0, + 0, + 103, + 417, + 1, + 0, + 0, + 0, + 105, + 437, + 1, + 0, + 0, + 0, + 107, + 460, + 1, + 0, + 0, + 0, + 109, + 470, + 1, + 0, + 0, + 0, + 111, + 478, + 1, + 0, + 0, + 0, + 113, + 490, + 1, + 0, + 0, + 0, + 115, + 497, + 1, + 0, + 0, + 0, + 117, + 505, + 1, + 0, + 0, + 0, + 119, + 510, + 1, + 0, + 0, + 0, + 121, + 514, + 1, + 0, + 0, + 0, + 123, + 518, + 1, + 0, + 0, + 0, + 125, + 521, + 1, + 0, + 0, + 0, + 127, + 526, + 1, + 0, + 0, + 0, + 129, + 530, + 1, + 0, + 0, + 0, + 131, + 535, + 1, + 0, + 0, + 0, + 133, + 538, + 1, + 0, + 0, + 0, + 135, + 543, + 1, + 0, + 0, + 0, + 137, + 549, + 1, + 0, + 0, + 0, + 139, + 554, + 1, + 0, + 0, + 0, + 141, + 558, + 1, + 0, + 0, + 0, + 143, + 562, + 1, + 0, + 0, + 0, + 145, + 568, + 1, + 0, + 0, + 0, + 147, + 574, + 1, + 0, + 0, + 0, + 149, + 580, + 1, + 0, + 0, + 0, + 151, + 585, + 1, + 0, + 0, + 0, + 153, + 588, + 1, + 0, + 0, + 0, + 155, + 595, + 1, + 0, + 0, + 0, + 157, + 597, + 1, + 0, + 0, + 0, + 159, + 599, + 1, + 0, + 0, + 0, + 161, + 601, + 1, + 0, + 0, + 0, + 163, + 603, + 1, + 0, + 0, + 0, + 165, + 605, + 1, + 0, + 0, + 0, + 167, + 607, + 1, + 0, + 0, + 0, + 169, + 609, + 1, + 0, + 0, + 0, + 171, + 611, + 1, + 0, + 0, + 0, + 173, + 613, + 1, + 0, + 0, + 0, + 175, + 615, + 1, + 0, + 0, + 0, + 177, + 617, + 1, + 0, + 0, + 0, + 179, + 180, + 5, + 47, + 0, + 0, + 180, + 181, + 5, + 47, + 0, + 0, + 181, + 185, + 1, + 0, + 0, + 0, + 182, + 184, + 8, + 0, + 0, + 0, + 183, + 182, + 1, + 0, + 0, + 0, + 184, + 187, + 1, + 0, + 0, + 0, + 185, + 183, + 1, + 0, + 0, + 0, + 185, + 186, + 1, + 0, + 0, + 0, + 186, + 188, + 1, + 0, + 0, + 0, + 187, + 185, + 1, + 0, + 0, + 0, + 188, + 189, + 6, + 0, + 0, + 0, + 189, + 2, + 1, + 0, + 0, + 0, + 190, + 191, + 5, + 47, + 0, + 0, + 191, + 192, + 5, + 42, + 0, + 0, + 192, + 200, + 1, + 0, + 0, + 0, + 193, + 201, + 8, + 1, + 0, + 0, + 194, + 196, + 5, + 42, + 0, + 0, + 195, + 194, + 1, + 0, + 0, + 0, + 196, + 197, + 1, + 0, + 0, + 0, + 197, + 195, + 1, + 0, + 0, + 0, + 197, + 198, + 1, + 0, + 0, + 0, + 198, + 199, + 1, + 0, + 0, + 0, + 199, + 201, + 8, + 2, + 0, + 0, + 200, + 193, + 1, + 0, + 0, + 0, + 200, + 195, + 1, + 0, + 0, + 0, + 201, + 205, + 1, + 0, + 0, + 0, + 202, + 204, + 5, + 42, + 0, + 0, + 203, + 202, + 1, + 0, + 0, + 0, + 204, + 207, + 1, + 0, + 0, + 0, + 205, + 203, + 1, + 0, + 0, + 0, + 205, + 206, + 1, + 0, + 0, + 0, + 206, + 208, + 1, + 0, + 0, + 0, + 207, + 205, + 1, + 0, + 0, + 0, + 208, + 209, + 5, + 42, + 0, + 0, + 209, + 210, + 5, + 47, + 0, + 0, + 210, + 211, + 1, + 0, + 0, + 0, + 211, + 212, + 6, + 1, + 0, + 0, + 212, + 4, + 1, + 0, + 0, + 0, + 213, + 215, + 7, + 3, + 0, + 0, + 214, + 213, + 1, + 0, + 0, + 0, + 215, + 216, + 1, + 0, + 0, + 0, + 216, + 214, + 1, + 0, + 0, + 0, + 216, + 217, + 1, + 0, + 0, + 0, + 217, + 218, + 1, + 0, + 0, + 0, + 218, + 219, + 6, + 2, + 0, + 0, + 219, + 6, + 1, + 0, + 0, + 0, + 220, + 221, + 7, + 4, + 0, + 0, + 221, + 8, + 1, + 0, + 0, + 0, + 222, + 223, + 7, + 5, + 0, + 0, + 223, + 10, + 1, + 0, + 0, + 0, + 224, + 225, + 7, + 6, + 0, + 0, + 225, + 12, + 1, + 0, + 0, + 0, + 226, + 227, + 7, + 7, + 0, + 0, + 227, + 14, + 1, + 0, + 0, + 0, + 228, + 229, + 7, + 8, + 0, + 0, + 229, + 16, + 1, + 0, + 0, + 0, + 230, + 231, + 7, + 9, + 0, + 0, + 231, + 18, + 1, + 0, + 0, + 0, + 232, + 233, + 7, + 10, + 0, + 0, + 233, + 20, + 1, + 0, + 0, + 0, + 234, + 235, + 7, + 11, + 0, + 0, + 235, + 22, + 1, + 0, + 0, + 0, + 236, + 237, + 7, + 12, + 0, + 0, + 237, + 24, + 1, + 0, + 0, + 0, + 238, + 239, + 7, + 13, + 0, + 0, + 239, + 26, + 1, + 0, + 0, + 0, + 240, + 241, + 7, + 14, + 0, + 0, + 241, + 28, + 1, + 0, + 0, + 0, + 242, + 243, + 7, + 15, + 0, + 0, + 243, + 30, + 1, + 0, + 0, + 0, + 244, + 245, + 7, + 16, + 0, + 0, + 245, + 32, + 1, + 0, + 0, + 0, + 246, + 247, + 7, + 17, + 0, + 0, + 247, + 34, + 1, + 0, + 0, + 0, + 248, + 249, + 7, + 18, + 0, + 0, + 249, + 36, + 1, + 0, + 0, + 0, + 250, + 251, + 7, + 19, + 0, + 0, + 251, + 38, + 1, + 0, + 0, + 0, + 252, + 253, + 7, + 20, + 0, + 0, + 253, + 40, + 1, + 0, + 0, + 0, + 254, + 255, + 7, + 21, + 0, + 0, + 255, + 42, + 1, + 0, + 0, + 0, + 256, + 257, + 7, + 22, + 0, + 0, + 257, + 44, + 1, + 0, + 0, + 0, + 258, + 259, + 7, + 23, + 0, + 0, + 259, + 46, + 1, + 0, + 0, + 0, + 260, + 261, + 7, + 24, + 0, + 0, + 261, + 48, + 1, + 0, + 0, + 0, + 262, + 263, + 7, + 25, + 0, + 0, + 263, + 50, + 1, + 0, + 0, + 0, + 264, + 265, + 7, + 26, + 0, + 0, + 265, + 52, + 1, + 0, + 0, + 0, + 266, + 267, + 7, + 27, + 0, + 0, + 267, + 54, + 1, + 0, + 0, + 0, + 268, + 269, + 7, + 28, + 0, + 0, + 269, + 56, + 1, + 0, + 0, + 0, + 270, + 271, + 7, + 29, + 0, + 0, + 271, + 58, + 1, + 0, + 0, + 0, + 272, + 273, + 7, + 30, + 0, + 0, + 273, + 60, + 1, + 0, + 0, + 0, + 274, + 283, + 5, + 48, + 0, + 0, + 275, + 279, + 7, + 31, + 0, + 0, + 276, + 278, + 7, + 30, + 0, + 0, + 277, + 276, + 1, + 0, + 0, + 0, + 278, + 281, + 1, + 0, + 0, + 0, + 279, + 277, + 1, + 0, + 0, + 0, + 279, + 280, + 1, + 0, + 0, + 0, + 280, + 283, + 1, + 0, + 0, + 0, + 281, + 279, + 1, + 0, + 0, + 0, + 282, + 274, + 1, + 0, + 0, + 0, + 282, + 275, + 1, + 0, + 0, + 0, + 283, + 62, + 1, + 0, + 0, + 0, + 284, + 285, + 3, + 23, + 11, + 0, + 285, + 286, + 3, + 17, + 8, + 0, + 286, + 64, + 1, + 0, + 0, + 0, + 287, + 288, + 3, + 45, + 22, + 0, + 288, + 289, + 3, + 21, + 10, + 0, + 289, + 290, + 3, + 15, + 7, + 0, + 290, + 291, + 3, + 33, + 16, + 0, + 291, + 66, + 1, + 0, + 0, + 0, + 292, + 293, + 3, + 15, + 7, + 0, + 293, + 294, + 3, + 29, + 14, + 0, + 294, + 295, + 3, + 43, + 21, + 0, + 295, + 296, + 3, + 15, + 7, + 0, + 296, + 68, + 1, + 0, + 0, + 0, + 297, + 298, + 3, + 9, + 4, + 0, + 298, + 299, + 3, + 35, + 17, + 0, + 299, + 300, + 3, + 35, + 17, + 0, + 300, + 301, + 3, + 29, + 14, + 0, + 301, + 302, + 3, + 15, + 7, + 0, + 302, + 303, + 3, + 7, + 3, + 0, + 303, + 304, + 3, + 33, + 16, + 0, + 304, + 70, + 1, + 0, + 0, + 0, + 305, + 306, + 3, + 23, + 11, + 0, + 306, + 307, + 5, + 56, + 0, + 0, + 307, + 72, + 1, + 0, + 0, + 0, + 308, + 309, + 3, + 23, + 11, + 0, + 309, + 310, + 5, + 49, + 0, + 0, + 310, + 311, + 5, + 54, + 0, + 0, + 311, + 74, + 1, + 0, + 0, + 0, + 312, + 313, + 3, + 23, + 11, + 0, + 313, + 314, + 5, + 51, + 0, + 0, + 314, + 315, + 5, + 50, + 0, + 0, + 315, + 76, + 1, + 0, + 0, + 0, + 316, + 317, + 3, + 23, + 11, + 0, + 317, + 318, + 5, + 54, + 0, + 0, + 318, + 319, + 5, + 52, + 0, + 0, + 319, + 78, + 1, + 0, + 0, + 0, + 320, + 321, + 3, + 17, + 8, + 0, + 321, + 322, + 3, + 37, + 18, + 0, + 322, + 323, + 5, + 51, + 0, + 0, + 323, + 324, + 5, + 50, + 0, + 0, + 324, + 80, + 1, + 0, + 0, + 0, + 325, + 326, + 3, + 17, + 8, + 0, + 326, + 327, + 3, + 37, + 18, + 0, + 327, + 328, + 5, + 54, + 0, + 0, + 328, + 329, + 5, + 52, + 0, + 0, + 329, + 82, + 1, + 0, + 0, + 0, + 330, + 331, + 3, + 43, + 21, + 0, + 331, + 332, + 3, + 45, + 22, + 0, + 332, + 333, + 3, + 41, + 20, + 0, + 333, + 334, + 3, + 23, + 11, + 0, + 334, + 335, + 3, + 33, + 16, + 0, + 335, + 336, + 3, + 19, + 9, + 0, + 336, + 84, + 1, + 0, + 0, + 0, + 337, + 338, + 3, + 9, + 4, + 0, + 338, + 339, + 3, + 23, + 11, + 0, + 339, + 340, + 3, + 33, + 16, + 0, + 340, + 341, + 3, + 7, + 3, + 0, + 341, + 342, + 3, + 41, + 20, + 0, + 342, + 343, + 3, + 55, + 27, + 0, + 343, + 86, + 1, + 0, + 0, + 0, + 344, + 345, + 3, + 45, + 22, + 0, + 345, + 346, + 3, + 23, + 11, + 0, + 346, + 347, + 3, + 31, + 15, + 0, + 347, + 348, + 3, + 15, + 7, + 0, + 348, + 349, + 3, + 43, + 21, + 0, + 349, + 350, + 3, + 45, + 22, + 0, + 350, + 351, + 3, + 7, + 3, + 0, + 351, + 352, + 3, + 31, + 15, + 0, + 352, + 353, + 3, + 37, + 18, + 0, + 353, + 88, + 1, + 0, + 0, + 0, + 354, + 355, + 3, + 45, + 22, + 0, + 355, + 356, + 3, + 23, + 11, + 0, + 356, + 357, + 3, + 31, + 15, + 0, + 357, + 358, + 3, + 15, + 7, + 0, + 358, + 359, + 3, + 43, + 21, + 0, + 359, + 360, + 3, + 45, + 22, + 0, + 360, + 361, + 3, + 7, + 3, + 0, + 361, + 362, + 3, + 31, + 15, + 0, + 362, + 363, + 3, + 37, + 18, + 0, + 363, + 364, + 5, + 95, + 0, + 0, + 364, + 365, + 3, + 45, + 22, + 0, + 365, + 366, + 3, + 57, + 28, + 0, + 366, + 90, + 1, + 0, + 0, + 0, + 367, + 368, + 3, + 13, + 6, + 0, + 368, + 369, + 3, + 7, + 3, + 0, + 369, + 370, + 3, + 45, + 22, + 0, + 370, + 371, + 3, + 15, + 7, + 0, + 371, + 92, + 1, + 0, + 0, + 0, + 372, + 373, + 3, + 45, + 22, + 0, + 373, + 374, + 3, + 23, + 11, + 0, + 374, + 375, + 3, + 31, + 15, + 0, + 375, + 376, + 3, + 15, + 7, + 0, + 376, + 94, + 1, + 0, + 0, + 0, + 377, + 378, + 3, + 23, + 11, + 0, + 378, + 379, + 3, + 33, + 16, + 0, + 379, + 380, + 3, + 45, + 22, + 0, + 380, + 381, + 3, + 15, + 7, + 0, + 381, + 382, + 3, + 41, + 20, + 0, + 382, + 383, + 3, + 49, + 24, + 0, + 383, + 384, + 3, + 7, + 3, + 0, + 384, + 385, + 3, + 29, + 14, + 0, + 385, + 386, + 5, + 95, + 0, + 0, + 386, + 387, + 3, + 55, + 27, + 0, + 387, + 388, + 3, + 15, + 7, + 0, + 388, + 389, + 3, + 7, + 3, + 0, + 389, + 390, + 3, + 41, + 20, + 0, + 390, + 96, + 1, + 0, + 0, + 0, + 391, + 392, + 3, + 23, + 11, + 0, + 392, + 393, + 3, + 33, + 16, + 0, + 393, + 394, + 3, + 45, + 22, + 0, + 394, + 395, + 3, + 15, + 7, + 0, + 395, + 396, + 3, + 41, + 20, + 0, + 396, + 397, + 3, + 49, + 24, + 0, + 397, + 398, + 3, + 7, + 3, + 0, + 398, + 399, + 3, + 29, + 14, + 0, + 399, + 400, + 5, + 95, + 0, + 0, + 400, + 401, + 3, + 13, + 6, + 0, + 401, + 402, + 3, + 7, + 3, + 0, + 402, + 403, + 3, + 55, + 27, + 0, + 403, + 98, + 1, + 0, + 0, + 0, + 404, + 405, + 3, + 47, + 23, + 0, + 405, + 406, + 3, + 47, + 23, + 0, + 406, + 407, + 3, + 23, + 11, + 0, + 407, + 408, + 3, + 13, + 6, + 0, + 408, + 100, + 1, + 0, + 0, + 0, + 409, + 410, + 3, + 13, + 6, + 0, + 410, + 411, + 3, + 15, + 7, + 0, + 411, + 412, + 3, + 11, + 5, + 0, + 412, + 413, + 3, + 23, + 11, + 0, + 413, + 414, + 3, + 31, + 15, + 0, + 414, + 415, + 3, + 7, + 3, + 0, + 415, + 416, + 3, + 29, + 14, + 0, + 416, + 102, + 1, + 0, + 0, + 0, + 417, + 418, + 3, + 37, + 18, + 0, + 418, + 419, + 3, + 41, + 20, + 0, + 419, + 420, + 3, + 15, + 7, + 0, + 420, + 421, + 3, + 11, + 5, + 0, + 421, + 422, + 3, + 23, + 11, + 0, + 422, + 423, + 3, + 43, + 21, + 0, + 423, + 424, + 3, + 23, + 11, + 0, + 424, + 425, + 3, + 35, + 17, + 0, + 425, + 426, + 3, + 33, + 16, + 0, + 426, + 427, + 5, + 95, + 0, + 0, + 427, + 428, + 3, + 45, + 22, + 0, + 428, + 429, + 3, + 23, + 11, + 0, + 429, + 430, + 3, + 31, + 15, + 0, + 430, + 431, + 3, + 15, + 7, + 0, + 431, + 432, + 3, + 43, + 21, + 0, + 432, + 433, + 3, + 45, + 22, + 0, + 433, + 434, + 3, + 7, + 3, + 0, + 434, + 435, + 3, + 31, + 15, + 0, + 435, + 436, + 3, + 37, + 18, + 0, + 436, + 104, + 1, + 0, + 0, + 0, + 437, + 438, + 3, + 37, + 18, + 0, + 438, + 439, + 3, + 41, + 20, + 0, + 439, + 440, + 3, + 15, + 7, + 0, + 440, + 441, + 3, + 11, + 5, + 0, + 441, + 442, + 3, + 23, + 11, + 0, + 442, + 443, + 3, + 43, + 21, + 0, + 443, + 444, + 3, + 23, + 11, + 0, + 444, + 445, + 3, + 35, + 17, + 0, + 445, + 446, + 3, + 33, + 16, + 0, + 446, + 447, + 5, + 95, + 0, + 0, + 447, + 448, + 3, + 45, + 22, + 0, + 448, + 449, + 3, + 23, + 11, + 0, + 449, + 450, + 3, + 31, + 15, + 0, + 450, + 451, + 3, + 15, + 7, + 0, + 451, + 452, + 3, + 43, + 21, + 0, + 452, + 453, + 3, + 45, + 22, + 0, + 453, + 454, + 3, + 7, + 3, + 0, + 454, + 455, + 3, + 31, + 15, + 0, + 455, + 456, + 3, + 37, + 18, + 0, + 456, + 457, + 5, + 95, + 0, + 0, + 457, + 458, + 3, + 45, + 22, + 0, + 458, + 459, + 3, + 57, + 28, + 0, + 459, + 106, + 1, + 0, + 0, + 0, + 460, + 461, + 3, + 17, + 8, + 0, + 461, + 462, + 3, + 23, + 11, + 0, + 462, + 463, + 3, + 53, + 26, + 0, + 463, + 464, + 3, + 15, + 7, + 0, + 464, + 465, + 3, + 13, + 6, + 0, + 465, + 466, + 3, + 11, + 5, + 0, + 466, + 467, + 3, + 21, + 10, + 0, + 467, + 468, + 3, + 7, + 3, + 0, + 468, + 469, + 3, + 41, + 20, + 0, + 469, + 108, + 1, + 0, + 0, + 0, + 470, + 471, + 3, + 49, + 24, + 0, + 471, + 472, + 3, + 7, + 3, + 0, + 472, + 473, + 3, + 41, + 20, + 0, + 473, + 474, + 3, + 11, + 5, + 0, + 474, + 475, + 3, + 21, + 10, + 0, + 475, + 476, + 3, + 7, + 3, + 0, + 476, + 477, + 3, + 41, + 20, + 0, + 477, + 110, + 1, + 0, + 0, + 0, + 478, + 479, + 3, + 17, + 8, + 0, + 479, + 480, + 3, + 23, + 11, + 0, + 480, + 481, + 3, + 53, + 26, + 0, + 481, + 482, + 3, + 15, + 7, + 0, + 482, + 483, + 3, + 13, + 6, + 0, + 483, + 484, + 3, + 9, + 4, + 0, + 484, + 485, + 3, + 23, + 11, + 0, + 485, + 486, + 3, + 33, + 16, + 0, + 486, + 487, + 3, + 7, + 3, + 0, + 487, + 488, + 3, + 41, + 20, + 0, + 488, + 489, + 3, + 55, + 27, + 0, + 489, + 112, + 1, + 0, + 0, + 0, + 490, + 491, + 3, + 43, + 21, + 0, + 491, + 492, + 3, + 45, + 22, + 0, + 492, + 493, + 3, + 41, + 20, + 0, + 493, + 494, + 3, + 47, + 23, + 0, + 494, + 495, + 3, + 11, + 5, + 0, + 495, + 496, + 3, + 45, + 22, + 0, + 496, + 114, + 1, + 0, + 0, + 0, + 497, + 498, + 3, + 33, + 16, + 0, + 498, + 499, + 3, + 43, + 21, + 0, + 499, + 500, + 3, + 45, + 22, + 0, + 500, + 501, + 3, + 41, + 20, + 0, + 501, + 502, + 3, + 47, + 23, + 0, + 502, + 503, + 3, + 11, + 5, + 0, + 503, + 504, + 3, + 45, + 22, + 0, + 504, + 116, + 1, + 0, + 0, + 0, + 505, + 506, + 3, + 29, + 14, + 0, + 506, + 507, + 3, + 23, + 11, + 0, + 507, + 508, + 3, + 43, + 21, + 0, + 508, + 509, + 3, + 45, + 22, + 0, + 509, + 118, + 1, + 0, + 0, + 0, + 510, + 511, + 3, + 31, + 15, + 0, + 511, + 512, + 3, + 7, + 3, + 0, + 512, + 513, + 3, + 37, + 18, + 0, + 513, + 120, + 1, + 0, + 0, + 0, + 514, + 515, + 3, + 7, + 3, + 0, + 515, + 516, + 3, + 33, + 16, + 0, + 516, + 517, + 3, + 55, + 27, + 0, + 517, + 122, + 1, + 0, + 0, + 0, + 518, + 519, + 3, + 47, + 23, + 0, + 519, + 520, + 5, + 33, + 0, + 0, + 520, + 124, + 1, + 0, + 0, + 0, + 521, + 522, + 3, + 9, + 4, + 0, + 522, + 523, + 3, + 35, + 17, + 0, + 523, + 524, + 3, + 35, + 17, + 0, + 524, + 525, + 3, + 29, + 14, + 0, + 525, + 126, + 1, + 0, + 0, + 0, + 526, + 527, + 3, + 43, + 21, + 0, + 527, + 528, + 3, + 45, + 22, + 0, + 528, + 529, + 3, + 41, + 20, + 0, + 529, + 128, + 1, + 0, + 0, + 0, + 530, + 531, + 3, + 49, + 24, + 0, + 531, + 532, + 3, + 9, + 4, + 0, + 532, + 533, + 3, + 23, + 11, + 0, + 533, + 534, + 3, + 33, + 16, + 0, + 534, + 130, + 1, + 0, + 0, + 0, + 535, + 536, + 3, + 45, + 22, + 0, + 536, + 537, + 3, + 43, + 21, + 0, + 537, + 132, + 1, + 0, + 0, + 0, + 538, + 539, + 3, + 45, + 22, + 0, + 539, + 540, + 3, + 43, + 21, + 0, + 540, + 541, + 3, + 45, + 22, + 0, + 541, + 542, + 3, + 57, + 28, + 0, + 542, + 134, + 1, + 0, + 0, + 0, + 543, + 544, + 3, + 23, + 11, + 0, + 544, + 545, + 3, + 55, + 27, + 0, + 545, + 546, + 3, + 15, + 7, + 0, + 546, + 547, + 3, + 7, + 3, + 0, + 547, + 548, + 3, + 41, + 20, + 0, + 548, + 136, + 1, + 0, + 0, + 0, + 549, + 550, + 3, + 23, + 11, + 0, + 550, + 551, + 3, + 13, + 6, + 0, + 551, + 552, + 3, + 7, + 3, + 0, + 552, + 553, + 3, + 55, + 27, + 0, + 553, + 138, + 1, + 0, + 0, + 0, + 554, + 555, + 3, + 13, + 6, + 0, + 555, + 556, + 3, + 15, + 7, + 0, + 556, + 557, + 3, + 11, + 5, + 0, + 557, + 140, + 1, + 0, + 0, + 0, + 558, + 559, + 3, + 37, + 18, + 0, + 559, + 560, + 3, + 45, + 22, + 0, + 560, + 561, + 3, + 43, + 21, + 0, + 561, + 142, + 1, + 0, + 0, + 0, + 562, + 563, + 3, + 37, + 18, + 0, + 563, + 564, + 3, + 45, + 22, + 0, + 564, + 565, + 3, + 43, + 21, + 0, + 565, + 566, + 3, + 45, + 22, + 0, + 566, + 567, + 3, + 57, + 28, + 0, + 567, + 144, + 1, + 0, + 0, + 0, + 568, + 569, + 3, + 17, + 8, + 0, + 569, + 570, + 3, + 11, + 5, + 0, + 570, + 571, + 3, + 21, + 10, + 0, + 571, + 572, + 3, + 7, + 3, + 0, + 572, + 573, + 3, + 41, + 20, + 0, + 573, + 146, + 1, + 0, + 0, + 0, + 574, + 575, + 3, + 49, + 24, + 0, + 575, + 576, + 3, + 11, + 5, + 0, + 576, + 577, + 3, + 21, + 10, + 0, + 577, + 578, + 3, + 7, + 3, + 0, + 578, + 579, + 3, + 41, + 20, + 0, + 579, + 148, + 1, + 0, + 0, + 0, + 580, + 581, + 3, + 17, + 8, + 0, + 581, + 582, + 3, + 9, + 4, + 0, + 582, + 583, + 3, + 23, + 11, + 0, + 583, + 584, + 3, + 33, + 16, + 0, + 584, + 150, + 1, + 0, + 0, + 0, + 585, + 586, + 5, + 58, + 0, + 0, + 586, + 587, + 5, + 58, + 0, + 0, + 587, + 152, + 1, + 0, + 0, + 0, + 588, + 592, + 7, + 32, + 0, + 0, + 589, + 591, + 7, + 33, + 0, + 0, + 590, + 589, + 1, + 0, + 0, + 0, + 591, + 594, + 1, + 0, + 0, + 0, + 592, + 590, + 1, + 0, + 0, + 0, + 592, + 593, + 1, + 0, + 0, + 0, + 593, + 154, + 1, + 0, + 0, + 0, + 594, + 592, + 1, + 0, + 0, + 0, + 595, + 596, + 5, + 60, + 0, + 0, + 596, + 156, + 1, + 0, + 0, + 0, + 597, + 598, + 5, + 62, + 0, + 0, + 598, + 158, + 1, + 0, + 0, + 0, + 599, + 600, + 5, + 40, + 0, + 0, + 600, + 160, + 1, + 0, + 0, + 0, + 601, + 602, + 5, + 41, + 0, + 0, + 602, + 162, + 1, + 0, + 0, + 0, + 603, + 604, + 5, + 91, + 0, + 0, + 604, + 164, + 1, + 0, + 0, + 0, + 605, + 606, + 5, + 93, + 0, + 0, + 606, + 166, + 1, + 0, + 0, + 0, + 607, + 608, + 5, + 44, + 0, + 0, + 608, + 168, + 1, + 0, + 0, + 0, + 609, + 610, + 5, + 61, + 0, + 0, + 610, + 170, + 1, + 0, + 0, + 0, + 611, + 612, + 5, + 58, + 0, + 0, + 612, + 172, + 1, + 0, + 0, + 0, + 613, + 614, + 5, + 63, + 0, + 0, + 614, + 174, + 1, + 0, + 0, + 0, + 615, + 616, + 5, + 35, + 0, + 0, + 616, + 176, + 1, + 0, + 0, + 0, + 617, + 618, + 5, + 46, + 0, + 0, + 618, + 178, + 1, + 0, + 0, + 0, + 9, + 0, + 185, + 197, + 200, + 205, + 216, + 279, + 282, + 592, + 1, + 0, + 1, + 0, ] + class SubstraitLexer(Lexer): atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] LineComment = 1 BlockComment = 2 @@ -297,48 +5331,191 @@ class SubstraitLexer(Lexer): HASH = 60 DOT = 61 - channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] - modeNames = [ "DEFAULT_MODE" ] + modeNames = ["DEFAULT_MODE"] - literalNames = [ "", - "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", - "':'", "'?'", "'#'", "'.'" ] + literalNames = [ + "", + "'::'", + "'<'", + "'>'", + "'('", + "')'", + "'['", + "']'", + "','", + "'='", + "':'", + "'?'", + "'#'", + "'.'", + ] - symbolicNames = [ "", - "LineComment", "BlockComment", "Whitespace", "If", "Then", "Else", - "Boolean", "I8", "I16", "I32", "I64", "FP32", "FP64", "String", - "Binary", "Timestamp", "TimestampTZ", "Date", "Time", "IntervalYear", - "IntervalDay", "UUID", "Decimal", "PrecisionTimestamp", "PrecisionTimestampTZ", - "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", - "List", "Map", "ANY", "UserDefined", "Bool", "Str", "VBin", - "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", "FChar", - "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", - "C_ANGLE_BRACKET", "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", - "COMMA", "EQ", "COLON", "QMARK", "HASH", "DOT" ] + symbolicNames = [ + "", + "LineComment", + "BlockComment", + "Whitespace", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "TimestampTZ", + "Date", + "Time", + "IntervalYear", + "IntervalDay", + "UUID", + "Decimal", + "PrecisionTimestamp", + "PrecisionTimestampTZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] - ruleNames = [ "LineComment", "BlockComment", "Whitespace", "A", "B", - "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", - "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", - "Y", "Z", "DIGIT", "INTEGER", "If", "Then", "Else", "Boolean", - "I8", "I16", "I32", "I64", "FP32", "FP64", "String", "Binary", - "Timestamp", "TimestampTZ", "Date", "Time", "IntervalYear", - "IntervalDay", "UUID", "Decimal", "PrecisionTimestamp", - "PrecisionTimestampTZ", "FixedChar", "VarChar", "FixedBinary", - "Struct", "NStruct", "List", "Map", "ANY", "UserDefined", - "Bool", "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", - "Dec", "PTs", "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", - "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", - "CPAREN", "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", - "QMARK", "HASH", "DOT" ] + ruleNames = [ + "LineComment", + "BlockComment", + "Whitespace", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "DIGIT", + "INTEGER", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "TimestampTZ", + "Date", + "Time", + "IntervalYear", + "IntervalDay", + "UUID", + "Decimal", + "PrecisionTimestamp", + "PrecisionTimestampTZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] grammarFileName = "SubstraitLexer.g4" - def __init__(self, input=None, output:TextIO = sys.stdout): + def __init__(self, input=None, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") - self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._interp = LexerATNSimulator( + self, self.atn, self.decisionsToDFA, PredictionContextCache() + ) self._actions = None self._predicates = None - - diff --git a/tests/coverage/antlr_parser/TestFileLexer.py b/tests/coverage/antlr_parser/TestFileLexer.py index 6f83b48b4..d510327cd 100644 --- a/tests/coverage/antlr_parser/TestFileLexer.py +++ b/tests/coverage/antlr_parser/TestFileLexer.py @@ -2,6 +2,7 @@ from antlr4 import * from io import StringIO import sys + if sys.version_info[1] > 5: from typing import TextIO else: @@ -10,424 +11,9680 @@ def serializedATN(): return [ - 4,0,94,1118,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, - 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, - 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, - 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, - 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, - 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, - 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, - 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, - 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, - 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, - 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, - 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, - 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, - 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2, - 91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7, - 97,2,98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103, - 7,103,2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108, - 2,109,7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114, - 7,114,2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119, - 2,120,7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,1,0, - 1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0, - 1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,4,1,281,8,1,11,1, - 12,1,282,1,1,1,1,4,1,287,8,1,11,1,12,1,288,3,1,291,8,1,1,2,1,2,1, - 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1, - 2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,5,3,320,8,3,10,3,12,3,323,9,3, - 1,3,3,3,326,8,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,5, - 1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,6,1,6,1,6,1,6, - 1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8, - 1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1, - 10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1,11,1, - 11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13,3,13,409,8,13,1,13,1, - 13,1,14,3,14,414,8,14,1,14,4,14,417,8,14,11,14,12,14,418,1,14,1, - 14,4,14,423,8,14,11,14,12,14,424,3,14,427,8,14,1,15,3,15,430,8,15, - 1,15,4,15,433,8,15,11,15,12,15,434,1,15,1,15,5,15,439,8,15,10,15, - 12,15,442,9,15,3,15,444,8,15,1,15,1,15,3,15,448,8,15,1,15,4,15,451, - 8,15,11,15,12,15,452,3,15,455,8,15,1,15,3,15,458,8,15,1,15,1,15, - 1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,473, - 8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16,484,8,16, - 1,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,19, - 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,4,19,508,8,19,11,19, - 12,19,509,3,19,512,8,19,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20, - 1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,4,20, - 534,8,20,11,20,12,20,535,3,20,538,8,20,1,20,1,20,1,21,1,21,1,21, - 1,21,1,21,1,21,1,21,1,21,4,21,550,8,21,11,21,12,21,551,3,21,554, - 8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,23,1,23, - 1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29,1,30, - 1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,589,8,31,1,31,1,31, - 1,31,1,31,1,31,1,31,1,31,1,31,3,31,599,8,31,1,32,1,32,1,32,1,32, - 1,32,1,32,1,32,3,32,608,8,32,1,32,1,32,1,32,1,32,1,32,1,32,1,32, - 1,32,3,32,618,8,32,1,33,1,33,1,33,1,33,1,33,3,33,625,8,33,1,33,1, - 33,1,33,3,33,630,8,33,1,33,1,33,1,33,3,33,635,8,33,1,33,1,33,1,33, - 1,33,1,33,3,33,642,8,33,1,33,1,33,1,33,3,33,647,8,33,1,33,1,33,1, - 33,1,33,1,33,3,33,654,8,33,1,33,1,33,1,33,3,33,659,8,33,1,34,1,34, - 1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,5,35,672,8,35,10,35, - 12,35,675,9,35,1,35,1,35,1,36,1,36,1,36,1,36,5,36,683,8,36,10,36, - 12,36,686,9,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,4,37,695,8,37, - 11,37,12,37,696,1,37,3,37,700,8,37,1,37,5,37,703,8,37,10,37,12,37, - 706,9,37,1,37,1,37,1,37,1,37,1,37,1,38,4,38,714,8,38,11,38,12,38, - 715,1,38,1,38,1,39,1,39,1,40,1,40,1,41,1,41,1,42,1,42,1,43,1,43, - 1,44,1,44,1,45,1,45,1,46,1,46,1,47,1,47,1,48,1,48,1,49,1,49,1,50, - 1,50,1,51,1,51,1,52,1,52,1,53,1,53,1,54,1,54,1,55,1,55,1,56,1,56, - 1,57,1,57,1,58,1,58,1,59,1,59,1,60,1,60,1,61,1,61,1,62,1,62,1,63, - 1,63,1,64,1,64,1,65,1,65,1,66,1,66,1,66,5,66,777,8,66,10,66,12,66, - 780,9,66,3,66,782,8,66,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1, - 69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1, - 71,1,71,1,71,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1,74,1,74,1, - 74,1,74,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1,76,1,77,1, - 77,1,77,1,77,1,77,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1, - 79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1,80,1,80,1, - 80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,81,1,81,1,81,1, - 81,1,81,1,82,1,82,1,82,1,82,1,82,1,83,1,83,1,83,1,83,1,83,1,83,1, - 83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1, - 84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,85,1,85,1,85,1,85,1,85,1, - 86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1,87,1,87,1, - 87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1, - 87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1, - 88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,89,1, - 89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,90,1,90,1,90,1,90,1, - 90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1, - 91,1,91,1,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,93,1,93,1,93,1, - 93,1,93,1,93,1,93,1,93,1,94,1,94,1,94,1,94,1,94,1,95,1,95,1,95,1, - 95,1,96,1,96,1,96,1,96,1,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1, - 99,1,99,1,99,1,99,1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101, - 1,102,1,102,1,102,1,102,1,102,1,103,1,103,1,103,1,103,1,103,1,103, - 1,104,1,104,1,104,1,104,1,104,1,105,1,105,1,105,1,105,1,106,1,106, - 1,106,1,106,1,107,1,107,1,107,1,107,1,107,1,107,1,108,1,108,1,108, - 1,108,1,108,1,108,1,109,1,109,1,109,1,109,1,109,1,109,1,110,1,110, - 1,110,1,110,1,110,1,111,1,111,1,111,1,112,1,112,5,112,1090,8,112, - 10,112,12,112,1093,9,112,1,113,1,113,1,114,1,114,1,115,1,115,1,116, - 1,116,1,117,1,117,1,118,1,118,1,119,1,119,1,120,1,120,1,121,1,121, - 1,122,1,122,1,123,1,123,1,124,1,124,0,0,125,1,1,3,2,5,3,7,4,9,5, - 11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,15,31,16,33, - 17,35,0,37,0,39,18,41,19,43,20,45,21,47,22,49,23,51,24,53,25,55, - 26,57,27,59,28,61,29,63,30,65,31,67,0,69,32,71,33,73,34,75,35,77, - 36,79,0,81,0,83,0,85,0,87,0,89,0,91,0,93,0,95,0,97,0,99,0,101,0, - 103,0,105,0,107,0,109,0,111,0,113,0,115,0,117,0,119,0,121,0,123, - 0,125,0,127,0,129,0,131,0,133,0,135,37,137,38,139,39,141,40,143, - 41,145,42,147,43,149,44,151,45,153,46,155,47,157,48,159,49,161,50, - 163,51,165,52,167,53,169,54,171,55,173,56,175,57,177,58,179,59,181, - 60,183,61,185,62,187,63,189,64,191,65,193,66,195,67,197,68,199,69, - 201,70,203,71,205,72,207,73,209,74,211,75,213,76,215,77,217,78,219, - 79,221,80,223,81,225,82,227,83,229,84,231,85,233,86,235,87,237,88, - 239,89,241,90,243,91,245,92,247,93,249,94,1,0,36,2,0,10,10,13,13, - 2,0,43,43,45,45,1,0,48,57,2,0,69,69,101,101,2,0,39,39,92,92,1,0, - 42,42,2,0,42,42,47,47,3,0,9,10,13,13,32,32,2,0,65,65,97,97,2,0,66, - 66,98,98,2,0,67,67,99,99,2,0,68,68,100,100,2,0,70,70,102,102,2,0, - 71,71,103,103,2,0,72,72,104,104,2,0,73,73,105,105,2,0,74,74,106, - 106,2,0,75,75,107,107,2,0,76,76,108,108,2,0,77,77,109,109,2,0,78, - 78,110,110,2,0,79,79,111,111,2,0,80,80,112,112,2,0,81,81,113,113, - 2,0,82,82,114,114,2,0,83,83,115,115,2,0,84,84,116,116,2,0,85,85, - 117,117,2,0,86,86,118,118,2,0,87,87,119,119,2,0,88,88,120,120,2, - 0,89,89,121,121,2,0,90,90,122,122,1,0,49,57,3,0,65,90,95,95,97,122, - 4,0,48,57,65,90,95,95,97,122,1139,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1, - 0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0, - 0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0, - 0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,39,1,0, - 0,0,0,41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0, - 0,0,0,51,1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0, - 0,0,0,61,1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,69,1,0,0,0,0,71,1,0, - 0,0,0,73,1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,135,1,0,0,0,0,137,1, - 0,0,0,0,139,1,0,0,0,0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0, - 147,1,0,0,0,0,149,1,0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0, - 0,0,0,157,1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165, - 1,0,0,0,0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0, - 0,175,1,0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,0,0,0,0,183,1, - 0,0,0,0,185,1,0,0,0,0,187,1,0,0,0,0,189,1,0,0,0,0,191,1,0,0,0,0, - 193,1,0,0,0,0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0,0,0,0,201,1,0, - 0,0,0,203,1,0,0,0,0,205,1,0,0,0,0,207,1,0,0,0,0,209,1,0,0,0,0,211, - 1,0,0,0,0,213,1,0,0,0,0,215,1,0,0,0,0,217,1,0,0,0,0,219,1,0,0,0, - 0,221,1,0,0,0,0,223,1,0,0,0,0,225,1,0,0,0,0,227,1,0,0,0,0,229,1, - 0,0,0,0,231,1,0,0,0,0,233,1,0,0,0,0,235,1,0,0,0,0,237,1,0,0,0,0, - 239,1,0,0,0,0,241,1,0,0,0,0,243,1,0,0,0,0,245,1,0,0,0,0,247,1,0, - 0,0,0,249,1,0,0,0,1,251,1,0,0,0,3,278,1,0,0,0,5,292,1,0,0,0,7,315, - 1,0,0,0,9,329,1,0,0,0,11,338,1,0,0,0,13,351,1,0,0,0,15,360,1,0,0, - 0,17,369,1,0,0,0,19,375,1,0,0,0,21,384,1,0,0,0,23,391,1,0,0,0,25, - 403,1,0,0,0,27,408,1,0,0,0,29,413,1,0,0,0,31,472,1,0,0,0,33,483, - 1,0,0,0,35,485,1,0,0,0,37,490,1,0,0,0,39,493,1,0,0,0,41,519,1,0, - 0,0,43,541,1,0,0,0,45,557,1,0,0,0,47,565,1,0,0,0,49,567,1,0,0,0, - 51,569,1,0,0,0,53,571,1,0,0,0,55,573,1,0,0,0,57,575,1,0,0,0,59,577, - 1,0,0,0,61,579,1,0,0,0,63,598,1,0,0,0,65,617,1,0,0,0,67,658,1,0, - 0,0,69,660,1,0,0,0,71,665,1,0,0,0,73,678,1,0,0,0,75,689,1,0,0,0, - 77,713,1,0,0,0,79,719,1,0,0,0,81,721,1,0,0,0,83,723,1,0,0,0,85,725, - 1,0,0,0,87,727,1,0,0,0,89,729,1,0,0,0,91,731,1,0,0,0,93,733,1,0, - 0,0,95,735,1,0,0,0,97,737,1,0,0,0,99,739,1,0,0,0,101,741,1,0,0,0, - 103,743,1,0,0,0,105,745,1,0,0,0,107,747,1,0,0,0,109,749,1,0,0,0, - 111,751,1,0,0,0,113,753,1,0,0,0,115,755,1,0,0,0,117,757,1,0,0,0, - 119,759,1,0,0,0,121,761,1,0,0,0,123,763,1,0,0,0,125,765,1,0,0,0, - 127,767,1,0,0,0,129,769,1,0,0,0,131,771,1,0,0,0,133,781,1,0,0,0, - 135,783,1,0,0,0,137,786,1,0,0,0,139,791,1,0,0,0,141,796,1,0,0,0, - 143,804,1,0,0,0,145,807,1,0,0,0,147,811,1,0,0,0,149,815,1,0,0,0, - 151,819,1,0,0,0,153,824,1,0,0,0,155,829,1,0,0,0,157,836,1,0,0,0, - 159,843,1,0,0,0,161,853,1,0,0,0,163,866,1,0,0,0,165,871,1,0,0,0, - 167,876,1,0,0,0,169,890,1,0,0,0,171,903,1,0,0,0,173,908,1,0,0,0, - 175,916,1,0,0,0,177,936,1,0,0,0,179,959,1,0,0,0,181,969,1,0,0,0, - 183,977,1,0,0,0,185,989,1,0,0,0,187,996,1,0,0,0,189,1004,1,0,0,0, - 191,1009,1,0,0,0,193,1013,1,0,0,0,195,1017,1,0,0,0,197,1020,1,0, - 0,0,199,1025,1,0,0,0,201,1029,1,0,0,0,203,1034,1,0,0,0,205,1037, - 1,0,0,0,207,1042,1,0,0,0,209,1048,1,0,0,0,211,1053,1,0,0,0,213,1057, - 1,0,0,0,215,1061,1,0,0,0,217,1067,1,0,0,0,219,1073,1,0,0,0,221,1079, - 1,0,0,0,223,1084,1,0,0,0,225,1087,1,0,0,0,227,1094,1,0,0,0,229,1096, - 1,0,0,0,231,1098,1,0,0,0,233,1100,1,0,0,0,235,1102,1,0,0,0,237,1104, - 1,0,0,0,239,1106,1,0,0,0,241,1108,1,0,0,0,243,1110,1,0,0,0,245,1112, - 1,0,0,0,247,1114,1,0,0,0,249,1116,1,0,0,0,251,252,5,35,0,0,252,253, - 5,35,0,0,253,254,5,35,0,0,254,255,5,32,0,0,255,256,5,83,0,0,256, - 257,5,85,0,0,257,258,5,66,0,0,258,259,5,83,0,0,259,260,5,84,0,0, - 260,261,5,82,0,0,261,262,5,65,0,0,262,263,5,73,0,0,263,264,5,84, - 0,0,264,265,5,95,0,0,265,266,5,83,0,0,266,267,5,67,0,0,267,268,5, - 65,0,0,268,269,5,76,0,0,269,270,5,65,0,0,270,271,5,82,0,0,271,272, - 5,95,0,0,272,273,5,84,0,0,273,274,5,69,0,0,274,275,5,83,0,0,275, - 276,5,84,0,0,276,277,5,58,0,0,277,2,1,0,0,0,278,280,5,118,0,0,279, - 281,3,131,65,0,280,279,1,0,0,0,281,282,1,0,0,0,282,280,1,0,0,0,282, - 283,1,0,0,0,283,290,1,0,0,0,284,286,5,46,0,0,285,287,3,131,65,0, - 286,285,1,0,0,0,287,288,1,0,0,0,288,286,1,0,0,0,288,289,1,0,0,0, - 289,291,1,0,0,0,290,284,1,0,0,0,290,291,1,0,0,0,291,4,1,0,0,0,292, - 293,5,35,0,0,293,294,5,35,0,0,294,295,5,35,0,0,295,296,5,32,0,0, - 296,297,5,83,0,0,297,298,5,85,0,0,298,299,5,66,0,0,299,300,5,83, - 0,0,300,301,5,84,0,0,301,302,5,82,0,0,302,303,5,65,0,0,303,304,5, - 73,0,0,304,305,5,84,0,0,305,306,5,95,0,0,306,307,5,73,0,0,307,308, - 5,78,0,0,308,309,5,67,0,0,309,310,5,76,0,0,310,311,5,85,0,0,311, - 312,5,68,0,0,312,313,5,69,0,0,313,314,5,58,0,0,314,6,1,0,0,0,315, - 316,5,35,0,0,316,317,5,32,0,0,317,321,1,0,0,0,318,320,8,0,0,0,319, - 318,1,0,0,0,320,323,1,0,0,0,321,319,1,0,0,0,321,322,1,0,0,0,322, - 325,1,0,0,0,323,321,1,0,0,0,324,326,5,13,0,0,325,324,1,0,0,0,325, - 326,1,0,0,0,326,327,1,0,0,0,327,328,5,10,0,0,328,8,1,0,0,0,329,330, - 5,60,0,0,330,331,5,33,0,0,331,332,5,69,0,0,332,333,5,82,0,0,333, - 334,5,82,0,0,334,335,5,79,0,0,335,336,5,82,0,0,336,337,5,62,0,0, - 337,10,1,0,0,0,338,339,5,60,0,0,339,340,5,33,0,0,340,341,5,85,0, - 0,341,342,5,78,0,0,342,343,5,68,0,0,343,344,5,69,0,0,344,345,5,70, - 0,0,345,346,5,73,0,0,346,347,5,78,0,0,347,348,5,69,0,0,348,349,5, - 68,0,0,349,350,5,62,0,0,350,12,1,0,0,0,351,352,5,111,0,0,352,353, - 5,118,0,0,353,354,5,101,0,0,354,355,5,114,0,0,355,356,5,108,0,0, - 356,357,5,102,0,0,357,358,5,111,0,0,358,359,5,119,0,0,359,14,1,0, - 0,0,360,361,5,114,0,0,361,362,5,111,0,0,362,363,5,117,0,0,363,364, - 5,110,0,0,364,365,5,100,0,0,365,366,5,105,0,0,366,367,5,110,0,0, - 367,368,5,103,0,0,368,16,1,0,0,0,369,370,5,69,0,0,370,371,5,82,0, - 0,371,372,5,82,0,0,372,373,5,79,0,0,373,374,5,82,0,0,374,18,1,0, - 0,0,375,376,5,83,0,0,376,377,5,65,0,0,377,378,5,84,0,0,378,379,5, - 85,0,0,379,380,5,82,0,0,380,381,5,65,0,0,381,382,5,84,0,0,382,383, - 5,69,0,0,383,20,1,0,0,0,384,385,5,83,0,0,385,386,5,73,0,0,386,387, - 5,76,0,0,387,388,5,69,0,0,388,389,5,78,0,0,389,390,5,84,0,0,390, - 22,1,0,0,0,391,392,5,84,0,0,392,393,5,73,0,0,393,394,5,69,0,0,394, - 395,5,95,0,0,395,396,5,84,0,0,396,397,5,79,0,0,397,398,5,95,0,0, - 398,399,5,69,0,0,399,400,5,86,0,0,400,401,5,69,0,0,401,402,5,78, - 0,0,402,24,1,0,0,0,403,404,5,78,0,0,404,405,5,65,0,0,405,406,5,78, - 0,0,406,26,1,0,0,0,407,409,7,1,0,0,408,407,1,0,0,0,408,409,1,0,0, - 0,409,410,1,0,0,0,410,411,3,133,66,0,411,28,1,0,0,0,412,414,7,1, - 0,0,413,412,1,0,0,0,413,414,1,0,0,0,414,416,1,0,0,0,415,417,7,2, - 0,0,416,415,1,0,0,0,417,418,1,0,0,0,418,416,1,0,0,0,418,419,1,0, - 0,0,419,426,1,0,0,0,420,422,5,46,0,0,421,423,7,2,0,0,422,421,1,0, - 0,0,423,424,1,0,0,0,424,422,1,0,0,0,424,425,1,0,0,0,425,427,1,0, - 0,0,426,420,1,0,0,0,426,427,1,0,0,0,427,30,1,0,0,0,428,430,7,1,0, - 0,429,428,1,0,0,0,429,430,1,0,0,0,430,432,1,0,0,0,431,433,7,2,0, - 0,432,431,1,0,0,0,433,434,1,0,0,0,434,432,1,0,0,0,434,435,1,0,0, - 0,435,443,1,0,0,0,436,440,5,46,0,0,437,439,7,2,0,0,438,437,1,0,0, - 0,439,442,1,0,0,0,440,438,1,0,0,0,440,441,1,0,0,0,441,444,1,0,0, - 0,442,440,1,0,0,0,443,436,1,0,0,0,443,444,1,0,0,0,444,454,1,0,0, - 0,445,447,7,3,0,0,446,448,7,1,0,0,447,446,1,0,0,0,447,448,1,0,0, - 0,448,450,1,0,0,0,449,451,7,2,0,0,450,449,1,0,0,0,451,452,1,0,0, - 0,452,450,1,0,0,0,452,453,1,0,0,0,453,455,1,0,0,0,454,445,1,0,0, - 0,454,455,1,0,0,0,455,473,1,0,0,0,456,458,7,1,0,0,457,456,1,0,0, - 0,457,458,1,0,0,0,458,459,1,0,0,0,459,460,5,105,0,0,460,461,5,110, - 0,0,461,473,5,102,0,0,462,463,5,110,0,0,463,464,5,97,0,0,464,473, - 5,110,0,0,465,466,5,78,0,0,466,467,5,97,0,0,467,473,5,78,0,0,468, - 469,5,115,0,0,469,470,5,110,0,0,470,471,5,97,0,0,471,473,5,110,0, - 0,472,429,1,0,0,0,472,457,1,0,0,0,472,462,1,0,0,0,472,465,1,0,0, - 0,472,468,1,0,0,0,473,32,1,0,0,0,474,475,5,116,0,0,475,476,5,114, - 0,0,476,477,5,117,0,0,477,484,5,101,0,0,478,479,5,102,0,0,479,480, - 5,97,0,0,480,481,5,108,0,0,481,482,5,115,0,0,482,484,5,101,0,0,483, - 474,1,0,0,0,483,478,1,0,0,0,484,34,1,0,0,0,485,486,7,2,0,0,486,487, - 7,2,0,0,487,488,7,2,0,0,488,489,7,2,0,0,489,36,1,0,0,0,490,491,7, - 2,0,0,491,492,7,2,0,0,492,38,1,0,0,0,493,494,5,39,0,0,494,495,3, - 35,17,0,495,496,5,45,0,0,496,497,3,37,18,0,497,498,5,45,0,0,498, - 499,3,37,18,0,499,500,5,84,0,0,500,501,3,37,18,0,501,502,5,58,0, - 0,502,503,3,37,18,0,503,504,5,58,0,0,504,511,3,37,18,0,505,507,5, - 46,0,0,506,508,7,2,0,0,507,506,1,0,0,0,508,509,1,0,0,0,509,507,1, - 0,0,0,509,510,1,0,0,0,510,512,1,0,0,0,511,505,1,0,0,0,511,512,1, - 0,0,0,512,513,1,0,0,0,513,514,7,1,0,0,514,515,3,37,18,0,515,516, - 5,58,0,0,516,517,3,37,18,0,517,518,5,39,0,0,518,40,1,0,0,0,519,520, - 5,39,0,0,520,521,3,35,17,0,521,522,5,45,0,0,522,523,3,37,18,0,523, - 524,5,45,0,0,524,525,3,37,18,0,525,526,5,84,0,0,526,527,3,37,18, - 0,527,528,5,58,0,0,528,529,3,37,18,0,529,530,5,58,0,0,530,537,3, - 37,18,0,531,533,5,46,0,0,532,534,7,2,0,0,533,532,1,0,0,0,534,535, - 1,0,0,0,535,533,1,0,0,0,535,536,1,0,0,0,536,538,1,0,0,0,537,531, - 1,0,0,0,537,538,1,0,0,0,538,539,1,0,0,0,539,540,5,39,0,0,540,42, - 1,0,0,0,541,542,5,39,0,0,542,543,3,37,18,0,543,544,5,58,0,0,544, - 545,3,37,18,0,545,546,5,58,0,0,546,553,3,37,18,0,547,549,5,46,0, - 0,548,550,7,2,0,0,549,548,1,0,0,0,550,551,1,0,0,0,551,549,1,0,0, - 0,551,552,1,0,0,0,552,554,1,0,0,0,553,547,1,0,0,0,553,554,1,0,0, - 0,554,555,1,0,0,0,555,556,5,39,0,0,556,44,1,0,0,0,557,558,5,39,0, - 0,558,559,3,35,17,0,559,560,5,45,0,0,560,561,3,37,18,0,561,562,5, - 45,0,0,562,563,3,37,18,0,563,564,5,39,0,0,564,46,1,0,0,0,565,566, - 5,80,0,0,566,48,1,0,0,0,567,568,5,84,0,0,568,50,1,0,0,0,569,570, - 5,89,0,0,570,52,1,0,0,0,571,572,5,77,0,0,572,54,1,0,0,0,573,574, - 5,68,0,0,574,56,1,0,0,0,575,576,5,72,0,0,576,58,1,0,0,0,577,578, - 5,83,0,0,578,60,1,0,0,0,579,580,5,70,0,0,580,62,1,0,0,0,581,582, - 5,39,0,0,582,583,3,47,23,0,583,584,3,27,13,0,584,588,3,51,25,0,585, - 586,3,27,13,0,586,587,3,53,26,0,587,589,1,0,0,0,588,585,1,0,0,0, - 588,589,1,0,0,0,589,590,1,0,0,0,590,591,5,39,0,0,591,599,1,0,0,0, - 592,593,5,39,0,0,593,594,3,47,23,0,594,595,3,27,13,0,595,596,3,53, - 26,0,596,597,5,39,0,0,597,599,1,0,0,0,598,581,1,0,0,0,598,592,1, - 0,0,0,599,64,1,0,0,0,600,601,5,39,0,0,601,602,3,47,23,0,602,603, - 3,27,13,0,603,607,3,55,27,0,604,605,3,49,24,0,605,606,3,67,33,0, - 606,608,1,0,0,0,607,604,1,0,0,0,607,608,1,0,0,0,608,609,1,0,0,0, - 609,610,5,39,0,0,610,618,1,0,0,0,611,612,5,39,0,0,612,613,3,47,23, - 0,613,614,3,49,24,0,614,615,3,67,33,0,615,616,5,39,0,0,616,618,1, - 0,0,0,617,600,1,0,0,0,617,611,1,0,0,0,618,66,1,0,0,0,619,620,3,27, - 13,0,620,624,3,57,28,0,621,622,3,27,13,0,622,623,3,53,26,0,623,625, - 1,0,0,0,624,621,1,0,0,0,624,625,1,0,0,0,625,629,1,0,0,0,626,627, - 3,27,13,0,627,628,3,59,29,0,628,630,1,0,0,0,629,626,1,0,0,0,629, - 630,1,0,0,0,630,634,1,0,0,0,631,632,3,27,13,0,632,633,3,61,30,0, - 633,635,1,0,0,0,634,631,1,0,0,0,634,635,1,0,0,0,635,659,1,0,0,0, - 636,637,3,27,13,0,637,641,3,53,26,0,638,639,3,27,13,0,639,640,3, - 59,29,0,640,642,1,0,0,0,641,638,1,0,0,0,641,642,1,0,0,0,642,646, - 1,0,0,0,643,644,3,27,13,0,644,645,3,61,30,0,645,647,1,0,0,0,646, - 643,1,0,0,0,646,647,1,0,0,0,647,659,1,0,0,0,648,649,3,27,13,0,649, - 653,3,59,29,0,650,651,3,27,13,0,651,652,3,61,30,0,652,654,1,0,0, - 0,653,650,1,0,0,0,653,654,1,0,0,0,654,659,1,0,0,0,655,656,3,27,13, - 0,656,657,3,61,30,0,657,659,1,0,0,0,658,619,1,0,0,0,658,636,1,0, - 0,0,658,648,1,0,0,0,658,655,1,0,0,0,659,68,1,0,0,0,660,661,5,110, - 0,0,661,662,5,117,0,0,662,663,5,108,0,0,663,664,5,108,0,0,664,70, - 1,0,0,0,665,673,5,39,0,0,666,667,5,92,0,0,667,672,9,0,0,0,668,669, - 5,39,0,0,669,672,5,39,0,0,670,672,8,4,0,0,671,666,1,0,0,0,671,668, - 1,0,0,0,671,670,1,0,0,0,672,675,1,0,0,0,673,671,1,0,0,0,673,674, - 1,0,0,0,674,676,1,0,0,0,675,673,1,0,0,0,676,677,5,39,0,0,677,72, - 1,0,0,0,678,679,5,47,0,0,679,680,5,47,0,0,680,684,1,0,0,0,681,683, - 8,0,0,0,682,681,1,0,0,0,683,686,1,0,0,0,684,682,1,0,0,0,684,685, - 1,0,0,0,685,687,1,0,0,0,686,684,1,0,0,0,687,688,6,36,0,0,688,74, - 1,0,0,0,689,690,5,47,0,0,690,691,5,42,0,0,691,699,1,0,0,0,692,700, - 8,5,0,0,693,695,5,42,0,0,694,693,1,0,0,0,695,696,1,0,0,0,696,694, - 1,0,0,0,696,697,1,0,0,0,697,698,1,0,0,0,698,700,8,6,0,0,699,692, - 1,0,0,0,699,694,1,0,0,0,700,704,1,0,0,0,701,703,5,42,0,0,702,701, - 1,0,0,0,703,706,1,0,0,0,704,702,1,0,0,0,704,705,1,0,0,0,705,707, - 1,0,0,0,706,704,1,0,0,0,707,708,5,42,0,0,708,709,5,47,0,0,709,710, - 1,0,0,0,710,711,6,37,0,0,711,76,1,0,0,0,712,714,7,7,0,0,713,712, - 1,0,0,0,714,715,1,0,0,0,715,713,1,0,0,0,715,716,1,0,0,0,716,717, - 1,0,0,0,717,718,6,38,0,0,718,78,1,0,0,0,719,720,7,8,0,0,720,80,1, - 0,0,0,721,722,7,9,0,0,722,82,1,0,0,0,723,724,7,10,0,0,724,84,1,0, - 0,0,725,726,7,11,0,0,726,86,1,0,0,0,727,728,7,3,0,0,728,88,1,0,0, - 0,729,730,7,12,0,0,730,90,1,0,0,0,731,732,7,13,0,0,732,92,1,0,0, - 0,733,734,7,14,0,0,734,94,1,0,0,0,735,736,7,15,0,0,736,96,1,0,0, - 0,737,738,7,16,0,0,738,98,1,0,0,0,739,740,7,17,0,0,740,100,1,0,0, - 0,741,742,7,18,0,0,742,102,1,0,0,0,743,744,7,19,0,0,744,104,1,0, - 0,0,745,746,7,20,0,0,746,106,1,0,0,0,747,748,7,21,0,0,748,108,1, - 0,0,0,749,750,7,22,0,0,750,110,1,0,0,0,751,752,7,23,0,0,752,112, - 1,0,0,0,753,754,7,24,0,0,754,114,1,0,0,0,755,756,7,25,0,0,756,116, - 1,0,0,0,757,758,7,26,0,0,758,118,1,0,0,0,759,760,7,27,0,0,760,120, - 1,0,0,0,761,762,7,28,0,0,762,122,1,0,0,0,763,764,7,29,0,0,764,124, - 1,0,0,0,765,766,7,30,0,0,766,126,1,0,0,0,767,768,7,31,0,0,768,128, - 1,0,0,0,769,770,7,32,0,0,770,130,1,0,0,0,771,772,7,2,0,0,772,132, - 1,0,0,0,773,782,5,48,0,0,774,778,7,33,0,0,775,777,7,2,0,0,776,775, - 1,0,0,0,777,780,1,0,0,0,778,776,1,0,0,0,778,779,1,0,0,0,779,782, - 1,0,0,0,780,778,1,0,0,0,781,773,1,0,0,0,781,774,1,0,0,0,782,134, - 1,0,0,0,783,784,3,95,47,0,784,785,3,89,44,0,785,136,1,0,0,0,786, - 787,3,117,58,0,787,788,3,93,46,0,788,789,3,87,43,0,789,790,3,105, - 52,0,790,138,1,0,0,0,791,792,3,87,43,0,792,793,3,101,50,0,793,794, - 3,115,57,0,794,795,3,87,43,0,795,140,1,0,0,0,796,797,3,81,40,0,797, - 798,3,107,53,0,798,799,3,107,53,0,799,800,3,101,50,0,800,801,3,87, - 43,0,801,802,3,79,39,0,802,803,3,105,52,0,803,142,1,0,0,0,804,805, - 3,95,47,0,805,806,5,56,0,0,806,144,1,0,0,0,807,808,3,95,47,0,808, - 809,5,49,0,0,809,810,5,54,0,0,810,146,1,0,0,0,811,812,3,95,47,0, - 812,813,5,51,0,0,813,814,5,50,0,0,814,148,1,0,0,0,815,816,3,95,47, - 0,816,817,5,54,0,0,817,818,5,52,0,0,818,150,1,0,0,0,819,820,3,89, - 44,0,820,821,3,109,54,0,821,822,5,51,0,0,822,823,5,50,0,0,823,152, - 1,0,0,0,824,825,3,89,44,0,825,826,3,109,54,0,826,827,5,54,0,0,827, - 828,5,52,0,0,828,154,1,0,0,0,829,830,3,115,57,0,830,831,3,117,58, - 0,831,832,3,113,56,0,832,833,3,95,47,0,833,834,3,105,52,0,834,835, - 3,91,45,0,835,156,1,0,0,0,836,837,3,81,40,0,837,838,3,95,47,0,838, - 839,3,105,52,0,839,840,3,79,39,0,840,841,3,113,56,0,841,842,3,127, - 63,0,842,158,1,0,0,0,843,844,3,117,58,0,844,845,3,95,47,0,845,846, - 3,103,51,0,846,847,3,87,43,0,847,848,3,115,57,0,848,849,3,117,58, - 0,849,850,3,79,39,0,850,851,3,103,51,0,851,852,3,109,54,0,852,160, - 1,0,0,0,853,854,3,117,58,0,854,855,3,95,47,0,855,856,3,103,51,0, - 856,857,3,87,43,0,857,858,3,115,57,0,858,859,3,117,58,0,859,860, - 3,79,39,0,860,861,3,103,51,0,861,862,3,109,54,0,862,863,5,95,0,0, - 863,864,3,117,58,0,864,865,3,129,64,0,865,162,1,0,0,0,866,867,3, - 85,42,0,867,868,3,79,39,0,868,869,3,117,58,0,869,870,3,87,43,0,870, - 164,1,0,0,0,871,872,3,117,58,0,872,873,3,95,47,0,873,874,3,103,51, - 0,874,875,3,87,43,0,875,166,1,0,0,0,876,877,3,95,47,0,877,878,3, - 105,52,0,878,879,3,117,58,0,879,880,3,87,43,0,880,881,3,113,56,0, - 881,882,3,121,60,0,882,883,3,79,39,0,883,884,3,101,50,0,884,885, - 5,95,0,0,885,886,3,127,63,0,886,887,3,87,43,0,887,888,3,79,39,0, - 888,889,3,113,56,0,889,168,1,0,0,0,890,891,3,95,47,0,891,892,3,105, - 52,0,892,893,3,117,58,0,893,894,3,87,43,0,894,895,3,113,56,0,895, - 896,3,121,60,0,896,897,3,79,39,0,897,898,3,101,50,0,898,899,5,95, - 0,0,899,900,3,85,42,0,900,901,3,79,39,0,901,902,3,127,63,0,902,170, - 1,0,0,0,903,904,3,119,59,0,904,905,3,119,59,0,905,906,3,95,47,0, - 906,907,3,85,42,0,907,172,1,0,0,0,908,909,3,85,42,0,909,910,3,87, - 43,0,910,911,3,83,41,0,911,912,3,95,47,0,912,913,3,103,51,0,913, - 914,3,79,39,0,914,915,3,101,50,0,915,174,1,0,0,0,916,917,3,109,54, - 0,917,918,3,113,56,0,918,919,3,87,43,0,919,920,3,83,41,0,920,921, - 3,95,47,0,921,922,3,115,57,0,922,923,3,95,47,0,923,924,3,107,53, - 0,924,925,3,105,52,0,925,926,5,95,0,0,926,927,3,117,58,0,927,928, - 3,95,47,0,928,929,3,103,51,0,929,930,3,87,43,0,930,931,3,115,57, - 0,931,932,3,117,58,0,932,933,3,79,39,0,933,934,3,103,51,0,934,935, - 3,109,54,0,935,176,1,0,0,0,936,937,3,109,54,0,937,938,3,113,56,0, - 938,939,3,87,43,0,939,940,3,83,41,0,940,941,3,95,47,0,941,942,3, - 115,57,0,942,943,3,95,47,0,943,944,3,107,53,0,944,945,3,105,52,0, - 945,946,5,95,0,0,946,947,3,117,58,0,947,948,3,95,47,0,948,949,3, - 103,51,0,949,950,3,87,43,0,950,951,3,115,57,0,951,952,3,117,58,0, - 952,953,3,79,39,0,953,954,3,103,51,0,954,955,3,109,54,0,955,956, - 5,95,0,0,956,957,3,117,58,0,957,958,3,129,64,0,958,178,1,0,0,0,959, - 960,3,89,44,0,960,961,3,95,47,0,961,962,3,125,62,0,962,963,3,87, - 43,0,963,964,3,85,42,0,964,965,3,83,41,0,965,966,3,93,46,0,966,967, - 3,79,39,0,967,968,3,113,56,0,968,180,1,0,0,0,969,970,3,121,60,0, - 970,971,3,79,39,0,971,972,3,113,56,0,972,973,3,83,41,0,973,974,3, - 93,46,0,974,975,3,79,39,0,975,976,3,113,56,0,976,182,1,0,0,0,977, - 978,3,89,44,0,978,979,3,95,47,0,979,980,3,125,62,0,980,981,3,87, - 43,0,981,982,3,85,42,0,982,983,3,81,40,0,983,984,3,95,47,0,984,985, - 3,105,52,0,985,986,3,79,39,0,986,987,3,113,56,0,987,988,3,127,63, - 0,988,184,1,0,0,0,989,990,3,115,57,0,990,991,3,117,58,0,991,992, - 3,113,56,0,992,993,3,119,59,0,993,994,3,83,41,0,994,995,3,117,58, - 0,995,186,1,0,0,0,996,997,3,105,52,0,997,998,3,115,57,0,998,999, - 3,117,58,0,999,1000,3,113,56,0,1000,1001,3,119,59,0,1001,1002,3, - 83,41,0,1002,1003,3,117,58,0,1003,188,1,0,0,0,1004,1005,3,101,50, - 0,1005,1006,3,95,47,0,1006,1007,3,115,57,0,1007,1008,3,117,58,0, - 1008,190,1,0,0,0,1009,1010,3,103,51,0,1010,1011,3,79,39,0,1011,1012, - 3,109,54,0,1012,192,1,0,0,0,1013,1014,3,79,39,0,1014,1015,3,105, - 52,0,1015,1016,3,127,63,0,1016,194,1,0,0,0,1017,1018,3,119,59,0, - 1018,1019,5,33,0,0,1019,196,1,0,0,0,1020,1021,3,81,40,0,1021,1022, - 3,107,53,0,1022,1023,3,107,53,0,1023,1024,3,101,50,0,1024,198,1, - 0,0,0,1025,1026,3,115,57,0,1026,1027,3,117,58,0,1027,1028,3,113, - 56,0,1028,200,1,0,0,0,1029,1030,3,121,60,0,1030,1031,3,81,40,0,1031, - 1032,3,95,47,0,1032,1033,3,105,52,0,1033,202,1,0,0,0,1034,1035,3, - 117,58,0,1035,1036,3,115,57,0,1036,204,1,0,0,0,1037,1038,3,117,58, - 0,1038,1039,3,115,57,0,1039,1040,3,117,58,0,1040,1041,3,129,64,0, - 1041,206,1,0,0,0,1042,1043,3,95,47,0,1043,1044,3,127,63,0,1044,1045, - 3,87,43,0,1045,1046,3,79,39,0,1046,1047,3,113,56,0,1047,208,1,0, - 0,0,1048,1049,3,95,47,0,1049,1050,3,85,42,0,1050,1051,3,79,39,0, - 1051,1052,3,127,63,0,1052,210,1,0,0,0,1053,1054,3,85,42,0,1054,1055, - 3,87,43,0,1055,1056,3,83,41,0,1056,212,1,0,0,0,1057,1058,3,109,54, - 0,1058,1059,3,117,58,0,1059,1060,3,115,57,0,1060,214,1,0,0,0,1061, - 1062,3,109,54,0,1062,1063,3,117,58,0,1063,1064,3,115,57,0,1064,1065, - 3,117,58,0,1065,1066,3,129,64,0,1066,216,1,0,0,0,1067,1068,3,89, - 44,0,1068,1069,3,83,41,0,1069,1070,3,93,46,0,1070,1071,3,79,39,0, - 1071,1072,3,113,56,0,1072,218,1,0,0,0,1073,1074,3,121,60,0,1074, - 1075,3,83,41,0,1075,1076,3,93,46,0,1076,1077,3,79,39,0,1077,1078, - 3,113,56,0,1078,220,1,0,0,0,1079,1080,3,89,44,0,1080,1081,3,81,40, - 0,1081,1082,3,95,47,0,1082,1083,3,105,52,0,1083,222,1,0,0,0,1084, - 1085,5,58,0,0,1085,1086,5,58,0,0,1086,224,1,0,0,0,1087,1091,7,34, - 0,0,1088,1090,7,35,0,0,1089,1088,1,0,0,0,1090,1093,1,0,0,0,1091, - 1089,1,0,0,0,1091,1092,1,0,0,0,1092,226,1,0,0,0,1093,1091,1,0,0, - 0,1094,1095,5,60,0,0,1095,228,1,0,0,0,1096,1097,5,62,0,0,1097,230, - 1,0,0,0,1098,1099,5,40,0,0,1099,232,1,0,0,0,1100,1101,5,41,0,0,1101, - 234,1,0,0,0,1102,1103,5,91,0,0,1103,236,1,0,0,0,1104,1105,5,93,0, - 0,1105,238,1,0,0,0,1106,1107,5,44,0,0,1107,240,1,0,0,0,1108,1109, - 5,61,0,0,1109,242,1,0,0,0,1110,1111,5,58,0,0,1111,244,1,0,0,0,1112, - 1113,5,63,0,0,1113,246,1,0,0,0,1114,1115,5,35,0,0,1115,248,1,0,0, - 0,1116,1117,5,46,0,0,1117,250,1,0,0,0,48,0,282,288,290,321,325,408, - 413,418,424,426,429,434,440,443,447,452,454,457,472,483,509,511, - 535,537,551,553,588,598,607,617,624,629,634,641,646,653,658,671, - 673,684,696,699,704,715,778,781,1091,1,0,1,0 + 4, + 0, + 94, + 1118, + 6, + -1, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 2, + 45, + 7, + 45, + 2, + 46, + 7, + 46, + 2, + 47, + 7, + 47, + 2, + 48, + 7, + 48, + 2, + 49, + 7, + 49, + 2, + 50, + 7, + 50, + 2, + 51, + 7, + 51, + 2, + 52, + 7, + 52, + 2, + 53, + 7, + 53, + 2, + 54, + 7, + 54, + 2, + 55, + 7, + 55, + 2, + 56, + 7, + 56, + 2, + 57, + 7, + 57, + 2, + 58, + 7, + 58, + 2, + 59, + 7, + 59, + 2, + 60, + 7, + 60, + 2, + 61, + 7, + 61, + 2, + 62, + 7, + 62, + 2, + 63, + 7, + 63, + 2, + 64, + 7, + 64, + 2, + 65, + 7, + 65, + 2, + 66, + 7, + 66, + 2, + 67, + 7, + 67, + 2, + 68, + 7, + 68, + 2, + 69, + 7, + 69, + 2, + 70, + 7, + 70, + 2, + 71, + 7, + 71, + 2, + 72, + 7, + 72, + 2, + 73, + 7, + 73, + 2, + 74, + 7, + 74, + 2, + 75, + 7, + 75, + 2, + 76, + 7, + 76, + 2, + 77, + 7, + 77, + 2, + 78, + 7, + 78, + 2, + 79, + 7, + 79, + 2, + 80, + 7, + 80, + 2, + 81, + 7, + 81, + 2, + 82, + 7, + 82, + 2, + 83, + 7, + 83, + 2, + 84, + 7, + 84, + 2, + 85, + 7, + 85, + 2, + 86, + 7, + 86, + 2, + 87, + 7, + 87, + 2, + 88, + 7, + 88, + 2, + 89, + 7, + 89, + 2, + 90, + 7, + 90, + 2, + 91, + 7, + 91, + 2, + 92, + 7, + 92, + 2, + 93, + 7, + 93, + 2, + 94, + 7, + 94, + 2, + 95, + 7, + 95, + 2, + 96, + 7, + 96, + 2, + 97, + 7, + 97, + 2, + 98, + 7, + 98, + 2, + 99, + 7, + 99, + 2, + 100, + 7, + 100, + 2, + 101, + 7, + 101, + 2, + 102, + 7, + 102, + 2, + 103, + 7, + 103, + 2, + 104, + 7, + 104, + 2, + 105, + 7, + 105, + 2, + 106, + 7, + 106, + 2, + 107, + 7, + 107, + 2, + 108, + 7, + 108, + 2, + 109, + 7, + 109, + 2, + 110, + 7, + 110, + 2, + 111, + 7, + 111, + 2, + 112, + 7, + 112, + 2, + 113, + 7, + 113, + 2, + 114, + 7, + 114, + 2, + 115, + 7, + 115, + 2, + 116, + 7, + 116, + 2, + 117, + 7, + 117, + 2, + 118, + 7, + 118, + 2, + 119, + 7, + 119, + 2, + 120, + 7, + 120, + 2, + 121, + 7, + 121, + 2, + 122, + 7, + 122, + 2, + 123, + 7, + 123, + 2, + 124, + 7, + 124, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 4, + 1, + 281, + 8, + 1, + 11, + 1, + 12, + 1, + 282, + 1, + 1, + 1, + 1, + 4, + 1, + 287, + 8, + 1, + 11, + 1, + 12, + 1, + 288, + 3, + 1, + 291, + 8, + 1, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 5, + 3, + 320, + 8, + 3, + 10, + 3, + 12, + 3, + 323, + 9, + 3, + 1, + 3, + 3, + 3, + 326, + 8, + 3, + 1, + 3, + 1, + 3, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 13, + 3, + 13, + 409, + 8, + 13, + 1, + 13, + 1, + 13, + 1, + 14, + 3, + 14, + 414, + 8, + 14, + 1, + 14, + 4, + 14, + 417, + 8, + 14, + 11, + 14, + 12, + 14, + 418, + 1, + 14, + 1, + 14, + 4, + 14, + 423, + 8, + 14, + 11, + 14, + 12, + 14, + 424, + 3, + 14, + 427, + 8, + 14, + 1, + 15, + 3, + 15, + 430, + 8, + 15, + 1, + 15, + 4, + 15, + 433, + 8, + 15, + 11, + 15, + 12, + 15, + 434, + 1, + 15, + 1, + 15, + 5, + 15, + 439, + 8, + 15, + 10, + 15, + 12, + 15, + 442, + 9, + 15, + 3, + 15, + 444, + 8, + 15, + 1, + 15, + 1, + 15, + 3, + 15, + 448, + 8, + 15, + 1, + 15, + 4, + 15, + 451, + 8, + 15, + 11, + 15, + 12, + 15, + 452, + 3, + 15, + 455, + 8, + 15, + 1, + 15, + 3, + 15, + 458, + 8, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 3, + 15, + 473, + 8, + 15, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 3, + 16, + 484, + 8, + 16, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 4, + 19, + 508, + 8, + 19, + 11, + 19, + 12, + 19, + 509, + 3, + 19, + 512, + 8, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 4, + 20, + 534, + 8, + 20, + 11, + 20, + 12, + 20, + 535, + 3, + 20, + 538, + 8, + 20, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 4, + 21, + 550, + 8, + 21, + 11, + 21, + 12, + 21, + 551, + 3, + 21, + 554, + 8, + 21, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 589, + 8, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 599, + 8, + 31, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 608, + 8, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 618, + 8, + 32, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 625, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 630, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 635, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 642, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 647, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 654, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 659, + 8, + 33, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 5, + 35, + 672, + 8, + 35, + 10, + 35, + 12, + 35, + 675, + 9, + 35, + 1, + 35, + 1, + 35, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 5, + 36, + 683, + 8, + 36, + 10, + 36, + 12, + 36, + 686, + 9, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 4, + 37, + 695, + 8, + 37, + 11, + 37, + 12, + 37, + 696, + 1, + 37, + 3, + 37, + 700, + 8, + 37, + 1, + 37, + 5, + 37, + 703, + 8, + 37, + 10, + 37, + 12, + 37, + 706, + 9, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 4, + 38, + 714, + 8, + 38, + 11, + 38, + 12, + 38, + 715, + 1, + 38, + 1, + 38, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, + 1, + 46, + 1, + 46, + 1, + 47, + 1, + 47, + 1, + 48, + 1, + 48, + 1, + 49, + 1, + 49, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 52, + 1, + 52, + 1, + 53, + 1, + 53, + 1, + 54, + 1, + 54, + 1, + 55, + 1, + 55, + 1, + 56, + 1, + 56, + 1, + 57, + 1, + 57, + 1, + 58, + 1, + 58, + 1, + 59, + 1, + 59, + 1, + 60, + 1, + 60, + 1, + 61, + 1, + 61, + 1, + 62, + 1, + 62, + 1, + 63, + 1, + 63, + 1, + 64, + 1, + 64, + 1, + 65, + 1, + 65, + 1, + 66, + 1, + 66, + 1, + 66, + 5, + 66, + 777, + 8, + 66, + 10, + 66, + 12, + 66, + 780, + 9, + 66, + 3, + 66, + 782, + 8, + 66, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 95, + 1, + 95, + 1, + 95, + 1, + 95, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 112, + 1, + 112, + 5, + 112, + 1090, + 8, + 112, + 10, + 112, + 12, + 112, + 1093, + 9, + 112, + 1, + 113, + 1, + 113, + 1, + 114, + 1, + 114, + 1, + 115, + 1, + 115, + 1, + 116, + 1, + 116, + 1, + 117, + 1, + 117, + 1, + 118, + 1, + 118, + 1, + 119, + 1, + 119, + 1, + 120, + 1, + 120, + 1, + 121, + 1, + 121, + 1, + 122, + 1, + 122, + 1, + 123, + 1, + 123, + 1, + 124, + 1, + 124, + 0, + 0, + 125, + 1, + 1, + 3, + 2, + 5, + 3, + 7, + 4, + 9, + 5, + 11, + 6, + 13, + 7, + 15, + 8, + 17, + 9, + 19, + 10, + 21, + 11, + 23, + 12, + 25, + 13, + 27, + 14, + 29, + 15, + 31, + 16, + 33, + 17, + 35, + 0, + 37, + 0, + 39, + 18, + 41, + 19, + 43, + 20, + 45, + 21, + 47, + 22, + 49, + 23, + 51, + 24, + 53, + 25, + 55, + 26, + 57, + 27, + 59, + 28, + 61, + 29, + 63, + 30, + 65, + 31, + 67, + 0, + 69, + 32, + 71, + 33, + 73, + 34, + 75, + 35, + 77, + 36, + 79, + 0, + 81, + 0, + 83, + 0, + 85, + 0, + 87, + 0, + 89, + 0, + 91, + 0, + 93, + 0, + 95, + 0, + 97, + 0, + 99, + 0, + 101, + 0, + 103, + 0, + 105, + 0, + 107, + 0, + 109, + 0, + 111, + 0, + 113, + 0, + 115, + 0, + 117, + 0, + 119, + 0, + 121, + 0, + 123, + 0, + 125, + 0, + 127, + 0, + 129, + 0, + 131, + 0, + 133, + 0, + 135, + 37, + 137, + 38, + 139, + 39, + 141, + 40, + 143, + 41, + 145, + 42, + 147, + 43, + 149, + 44, + 151, + 45, + 153, + 46, + 155, + 47, + 157, + 48, + 159, + 49, + 161, + 50, + 163, + 51, + 165, + 52, + 167, + 53, + 169, + 54, + 171, + 55, + 173, + 56, + 175, + 57, + 177, + 58, + 179, + 59, + 181, + 60, + 183, + 61, + 185, + 62, + 187, + 63, + 189, + 64, + 191, + 65, + 193, + 66, + 195, + 67, + 197, + 68, + 199, + 69, + 201, + 70, + 203, + 71, + 205, + 72, + 207, + 73, + 209, + 74, + 211, + 75, + 213, + 76, + 215, + 77, + 217, + 78, + 219, + 79, + 221, + 80, + 223, + 81, + 225, + 82, + 227, + 83, + 229, + 84, + 231, + 85, + 233, + 86, + 235, + 87, + 237, + 88, + 239, + 89, + 241, + 90, + 243, + 91, + 245, + 92, + 247, + 93, + 249, + 94, + 1, + 0, + 36, + 2, + 0, + 10, + 10, + 13, + 13, + 2, + 0, + 43, + 43, + 45, + 45, + 1, + 0, + 48, + 57, + 2, + 0, + 69, + 69, + 101, + 101, + 2, + 0, + 39, + 39, + 92, + 92, + 1, + 0, + 42, + 42, + 2, + 0, + 42, + 42, + 47, + 47, + 3, + 0, + 9, + 10, + 13, + 13, + 32, + 32, + 2, + 0, + 65, + 65, + 97, + 97, + 2, + 0, + 66, + 66, + 98, + 98, + 2, + 0, + 67, + 67, + 99, + 99, + 2, + 0, + 68, + 68, + 100, + 100, + 2, + 0, + 70, + 70, + 102, + 102, + 2, + 0, + 71, + 71, + 103, + 103, + 2, + 0, + 72, + 72, + 104, + 104, + 2, + 0, + 73, + 73, + 105, + 105, + 2, + 0, + 74, + 74, + 106, + 106, + 2, + 0, + 75, + 75, + 107, + 107, + 2, + 0, + 76, + 76, + 108, + 108, + 2, + 0, + 77, + 77, + 109, + 109, + 2, + 0, + 78, + 78, + 110, + 110, + 2, + 0, + 79, + 79, + 111, + 111, + 2, + 0, + 80, + 80, + 112, + 112, + 2, + 0, + 81, + 81, + 113, + 113, + 2, + 0, + 82, + 82, + 114, + 114, + 2, + 0, + 83, + 83, + 115, + 115, + 2, + 0, + 84, + 84, + 116, + 116, + 2, + 0, + 85, + 85, + 117, + 117, + 2, + 0, + 86, + 86, + 118, + 118, + 2, + 0, + 87, + 87, + 119, + 119, + 2, + 0, + 88, + 88, + 120, + 120, + 2, + 0, + 89, + 89, + 121, + 121, + 2, + 0, + 90, + 90, + 122, + 122, + 1, + 0, + 49, + 57, + 3, + 0, + 65, + 90, + 95, + 95, + 97, + 122, + 4, + 0, + 48, + 57, + 65, + 90, + 95, + 95, + 97, + 122, + 1139, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 5, + 1, + 0, + 0, + 0, + 0, + 7, + 1, + 0, + 0, + 0, + 0, + 9, + 1, + 0, + 0, + 0, + 0, + 11, + 1, + 0, + 0, + 0, + 0, + 13, + 1, + 0, + 0, + 0, + 0, + 15, + 1, + 0, + 0, + 0, + 0, + 17, + 1, + 0, + 0, + 0, + 0, + 19, + 1, + 0, + 0, + 0, + 0, + 21, + 1, + 0, + 0, + 0, + 0, + 23, + 1, + 0, + 0, + 0, + 0, + 25, + 1, + 0, + 0, + 0, + 0, + 27, + 1, + 0, + 0, + 0, + 0, + 29, + 1, + 0, + 0, + 0, + 0, + 31, + 1, + 0, + 0, + 0, + 0, + 33, + 1, + 0, + 0, + 0, + 0, + 39, + 1, + 0, + 0, + 0, + 0, + 41, + 1, + 0, + 0, + 0, + 0, + 43, + 1, + 0, + 0, + 0, + 0, + 45, + 1, + 0, + 0, + 0, + 0, + 47, + 1, + 0, + 0, + 0, + 0, + 49, + 1, + 0, + 0, + 0, + 0, + 51, + 1, + 0, + 0, + 0, + 0, + 53, + 1, + 0, + 0, + 0, + 0, + 55, + 1, + 0, + 0, + 0, + 0, + 57, + 1, + 0, + 0, + 0, + 0, + 59, + 1, + 0, + 0, + 0, + 0, + 61, + 1, + 0, + 0, + 0, + 0, + 63, + 1, + 0, + 0, + 0, + 0, + 65, + 1, + 0, + 0, + 0, + 0, + 69, + 1, + 0, + 0, + 0, + 0, + 71, + 1, + 0, + 0, + 0, + 0, + 73, + 1, + 0, + 0, + 0, + 0, + 75, + 1, + 0, + 0, + 0, + 0, + 77, + 1, + 0, + 0, + 0, + 0, + 135, + 1, + 0, + 0, + 0, + 0, + 137, + 1, + 0, + 0, + 0, + 0, + 139, + 1, + 0, + 0, + 0, + 0, + 141, + 1, + 0, + 0, + 0, + 0, + 143, + 1, + 0, + 0, + 0, + 0, + 145, + 1, + 0, + 0, + 0, + 0, + 147, + 1, + 0, + 0, + 0, + 0, + 149, + 1, + 0, + 0, + 0, + 0, + 151, + 1, + 0, + 0, + 0, + 0, + 153, + 1, + 0, + 0, + 0, + 0, + 155, + 1, + 0, + 0, + 0, + 0, + 157, + 1, + 0, + 0, + 0, + 0, + 159, + 1, + 0, + 0, + 0, + 0, + 161, + 1, + 0, + 0, + 0, + 0, + 163, + 1, + 0, + 0, + 0, + 0, + 165, + 1, + 0, + 0, + 0, + 0, + 167, + 1, + 0, + 0, + 0, + 0, + 169, + 1, + 0, + 0, + 0, + 0, + 171, + 1, + 0, + 0, + 0, + 0, + 173, + 1, + 0, + 0, + 0, + 0, + 175, + 1, + 0, + 0, + 0, + 0, + 177, + 1, + 0, + 0, + 0, + 0, + 179, + 1, + 0, + 0, + 0, + 0, + 181, + 1, + 0, + 0, + 0, + 0, + 183, + 1, + 0, + 0, + 0, + 0, + 185, + 1, + 0, + 0, + 0, + 0, + 187, + 1, + 0, + 0, + 0, + 0, + 189, + 1, + 0, + 0, + 0, + 0, + 191, + 1, + 0, + 0, + 0, + 0, + 193, + 1, + 0, + 0, + 0, + 0, + 195, + 1, + 0, + 0, + 0, + 0, + 197, + 1, + 0, + 0, + 0, + 0, + 199, + 1, + 0, + 0, + 0, + 0, + 201, + 1, + 0, + 0, + 0, + 0, + 203, + 1, + 0, + 0, + 0, + 0, + 205, + 1, + 0, + 0, + 0, + 0, + 207, + 1, + 0, + 0, + 0, + 0, + 209, + 1, + 0, + 0, + 0, + 0, + 211, + 1, + 0, + 0, + 0, + 0, + 213, + 1, + 0, + 0, + 0, + 0, + 215, + 1, + 0, + 0, + 0, + 0, + 217, + 1, + 0, + 0, + 0, + 0, + 219, + 1, + 0, + 0, + 0, + 0, + 221, + 1, + 0, + 0, + 0, + 0, + 223, + 1, + 0, + 0, + 0, + 0, + 225, + 1, + 0, + 0, + 0, + 0, + 227, + 1, + 0, + 0, + 0, + 0, + 229, + 1, + 0, + 0, + 0, + 0, + 231, + 1, + 0, + 0, + 0, + 0, + 233, + 1, + 0, + 0, + 0, + 0, + 235, + 1, + 0, + 0, + 0, + 0, + 237, + 1, + 0, + 0, + 0, + 0, + 239, + 1, + 0, + 0, + 0, + 0, + 241, + 1, + 0, + 0, + 0, + 0, + 243, + 1, + 0, + 0, + 0, + 0, + 245, + 1, + 0, + 0, + 0, + 0, + 247, + 1, + 0, + 0, + 0, + 0, + 249, + 1, + 0, + 0, + 0, + 1, + 251, + 1, + 0, + 0, + 0, + 3, + 278, + 1, + 0, + 0, + 0, + 5, + 292, + 1, + 0, + 0, + 0, + 7, + 315, + 1, + 0, + 0, + 0, + 9, + 329, + 1, + 0, + 0, + 0, + 11, + 338, + 1, + 0, + 0, + 0, + 13, + 351, + 1, + 0, + 0, + 0, + 15, + 360, + 1, + 0, + 0, + 0, + 17, + 369, + 1, + 0, + 0, + 0, + 19, + 375, + 1, + 0, + 0, + 0, + 21, + 384, + 1, + 0, + 0, + 0, + 23, + 391, + 1, + 0, + 0, + 0, + 25, + 403, + 1, + 0, + 0, + 0, + 27, + 408, + 1, + 0, + 0, + 0, + 29, + 413, + 1, + 0, + 0, + 0, + 31, + 472, + 1, + 0, + 0, + 0, + 33, + 483, + 1, + 0, + 0, + 0, + 35, + 485, + 1, + 0, + 0, + 0, + 37, + 490, + 1, + 0, + 0, + 0, + 39, + 493, + 1, + 0, + 0, + 0, + 41, + 519, + 1, + 0, + 0, + 0, + 43, + 541, + 1, + 0, + 0, + 0, + 45, + 557, + 1, + 0, + 0, + 0, + 47, + 565, + 1, + 0, + 0, + 0, + 49, + 567, + 1, + 0, + 0, + 0, + 51, + 569, + 1, + 0, + 0, + 0, + 53, + 571, + 1, + 0, + 0, + 0, + 55, + 573, + 1, + 0, + 0, + 0, + 57, + 575, + 1, + 0, + 0, + 0, + 59, + 577, + 1, + 0, + 0, + 0, + 61, + 579, + 1, + 0, + 0, + 0, + 63, + 598, + 1, + 0, + 0, + 0, + 65, + 617, + 1, + 0, + 0, + 0, + 67, + 658, + 1, + 0, + 0, + 0, + 69, + 660, + 1, + 0, + 0, + 0, + 71, + 665, + 1, + 0, + 0, + 0, + 73, + 678, + 1, + 0, + 0, + 0, + 75, + 689, + 1, + 0, + 0, + 0, + 77, + 713, + 1, + 0, + 0, + 0, + 79, + 719, + 1, + 0, + 0, + 0, + 81, + 721, + 1, + 0, + 0, + 0, + 83, + 723, + 1, + 0, + 0, + 0, + 85, + 725, + 1, + 0, + 0, + 0, + 87, + 727, + 1, + 0, + 0, + 0, + 89, + 729, + 1, + 0, + 0, + 0, + 91, + 731, + 1, + 0, + 0, + 0, + 93, + 733, + 1, + 0, + 0, + 0, + 95, + 735, + 1, + 0, + 0, + 0, + 97, + 737, + 1, + 0, + 0, + 0, + 99, + 739, + 1, + 0, + 0, + 0, + 101, + 741, + 1, + 0, + 0, + 0, + 103, + 743, + 1, + 0, + 0, + 0, + 105, + 745, + 1, + 0, + 0, + 0, + 107, + 747, + 1, + 0, + 0, + 0, + 109, + 749, + 1, + 0, + 0, + 0, + 111, + 751, + 1, + 0, + 0, + 0, + 113, + 753, + 1, + 0, + 0, + 0, + 115, + 755, + 1, + 0, + 0, + 0, + 117, + 757, + 1, + 0, + 0, + 0, + 119, + 759, + 1, + 0, + 0, + 0, + 121, + 761, + 1, + 0, + 0, + 0, + 123, + 763, + 1, + 0, + 0, + 0, + 125, + 765, + 1, + 0, + 0, + 0, + 127, + 767, + 1, + 0, + 0, + 0, + 129, + 769, + 1, + 0, + 0, + 0, + 131, + 771, + 1, + 0, + 0, + 0, + 133, + 781, + 1, + 0, + 0, + 0, + 135, + 783, + 1, + 0, + 0, + 0, + 137, + 786, + 1, + 0, + 0, + 0, + 139, + 791, + 1, + 0, + 0, + 0, + 141, + 796, + 1, + 0, + 0, + 0, + 143, + 804, + 1, + 0, + 0, + 0, + 145, + 807, + 1, + 0, + 0, + 0, + 147, + 811, + 1, + 0, + 0, + 0, + 149, + 815, + 1, + 0, + 0, + 0, + 151, + 819, + 1, + 0, + 0, + 0, + 153, + 824, + 1, + 0, + 0, + 0, + 155, + 829, + 1, + 0, + 0, + 0, + 157, + 836, + 1, + 0, + 0, + 0, + 159, + 843, + 1, + 0, + 0, + 0, + 161, + 853, + 1, + 0, + 0, + 0, + 163, + 866, + 1, + 0, + 0, + 0, + 165, + 871, + 1, + 0, + 0, + 0, + 167, + 876, + 1, + 0, + 0, + 0, + 169, + 890, + 1, + 0, + 0, + 0, + 171, + 903, + 1, + 0, + 0, + 0, + 173, + 908, + 1, + 0, + 0, + 0, + 175, + 916, + 1, + 0, + 0, + 0, + 177, + 936, + 1, + 0, + 0, + 0, + 179, + 959, + 1, + 0, + 0, + 0, + 181, + 969, + 1, + 0, + 0, + 0, + 183, + 977, + 1, + 0, + 0, + 0, + 185, + 989, + 1, + 0, + 0, + 0, + 187, + 996, + 1, + 0, + 0, + 0, + 189, + 1004, + 1, + 0, + 0, + 0, + 191, + 1009, + 1, + 0, + 0, + 0, + 193, + 1013, + 1, + 0, + 0, + 0, + 195, + 1017, + 1, + 0, + 0, + 0, + 197, + 1020, + 1, + 0, + 0, + 0, + 199, + 1025, + 1, + 0, + 0, + 0, + 201, + 1029, + 1, + 0, + 0, + 0, + 203, + 1034, + 1, + 0, + 0, + 0, + 205, + 1037, + 1, + 0, + 0, + 0, + 207, + 1042, + 1, + 0, + 0, + 0, + 209, + 1048, + 1, + 0, + 0, + 0, + 211, + 1053, + 1, + 0, + 0, + 0, + 213, + 1057, + 1, + 0, + 0, + 0, + 215, + 1061, + 1, + 0, + 0, + 0, + 217, + 1067, + 1, + 0, + 0, + 0, + 219, + 1073, + 1, + 0, + 0, + 0, + 221, + 1079, + 1, + 0, + 0, + 0, + 223, + 1084, + 1, + 0, + 0, + 0, + 225, + 1087, + 1, + 0, + 0, + 0, + 227, + 1094, + 1, + 0, + 0, + 0, + 229, + 1096, + 1, + 0, + 0, + 0, + 231, + 1098, + 1, + 0, + 0, + 0, + 233, + 1100, + 1, + 0, + 0, + 0, + 235, + 1102, + 1, + 0, + 0, + 0, + 237, + 1104, + 1, + 0, + 0, + 0, + 239, + 1106, + 1, + 0, + 0, + 0, + 241, + 1108, + 1, + 0, + 0, + 0, + 243, + 1110, + 1, + 0, + 0, + 0, + 245, + 1112, + 1, + 0, + 0, + 0, + 247, + 1114, + 1, + 0, + 0, + 0, + 249, + 1116, + 1, + 0, + 0, + 0, + 251, + 252, + 5, + 35, + 0, + 0, + 252, + 253, + 5, + 35, + 0, + 0, + 253, + 254, + 5, + 35, + 0, + 0, + 254, + 255, + 5, + 32, + 0, + 0, + 255, + 256, + 5, + 83, + 0, + 0, + 256, + 257, + 5, + 85, + 0, + 0, + 257, + 258, + 5, + 66, + 0, + 0, + 258, + 259, + 5, + 83, + 0, + 0, + 259, + 260, + 5, + 84, + 0, + 0, + 260, + 261, + 5, + 82, + 0, + 0, + 261, + 262, + 5, + 65, + 0, + 0, + 262, + 263, + 5, + 73, + 0, + 0, + 263, + 264, + 5, + 84, + 0, + 0, + 264, + 265, + 5, + 95, + 0, + 0, + 265, + 266, + 5, + 83, + 0, + 0, + 266, + 267, + 5, + 67, + 0, + 0, + 267, + 268, + 5, + 65, + 0, + 0, + 268, + 269, + 5, + 76, + 0, + 0, + 269, + 270, + 5, + 65, + 0, + 0, + 270, + 271, + 5, + 82, + 0, + 0, + 271, + 272, + 5, + 95, + 0, + 0, + 272, + 273, + 5, + 84, + 0, + 0, + 273, + 274, + 5, + 69, + 0, + 0, + 274, + 275, + 5, + 83, + 0, + 0, + 275, + 276, + 5, + 84, + 0, + 0, + 276, + 277, + 5, + 58, + 0, + 0, + 277, + 2, + 1, + 0, + 0, + 0, + 278, + 280, + 5, + 118, + 0, + 0, + 279, + 281, + 3, + 131, + 65, + 0, + 280, + 279, + 1, + 0, + 0, + 0, + 281, + 282, + 1, + 0, + 0, + 0, + 282, + 280, + 1, + 0, + 0, + 0, + 282, + 283, + 1, + 0, + 0, + 0, + 283, + 290, + 1, + 0, + 0, + 0, + 284, + 286, + 5, + 46, + 0, + 0, + 285, + 287, + 3, + 131, + 65, + 0, + 286, + 285, + 1, + 0, + 0, + 0, + 287, + 288, + 1, + 0, + 0, + 0, + 288, + 286, + 1, + 0, + 0, + 0, + 288, + 289, + 1, + 0, + 0, + 0, + 289, + 291, + 1, + 0, + 0, + 0, + 290, + 284, + 1, + 0, + 0, + 0, + 290, + 291, + 1, + 0, + 0, + 0, + 291, + 4, + 1, + 0, + 0, + 0, + 292, + 293, + 5, + 35, + 0, + 0, + 293, + 294, + 5, + 35, + 0, + 0, + 294, + 295, + 5, + 35, + 0, + 0, + 295, + 296, + 5, + 32, + 0, + 0, + 296, + 297, + 5, + 83, + 0, + 0, + 297, + 298, + 5, + 85, + 0, + 0, + 298, + 299, + 5, + 66, + 0, + 0, + 299, + 300, + 5, + 83, + 0, + 0, + 300, + 301, + 5, + 84, + 0, + 0, + 301, + 302, + 5, + 82, + 0, + 0, + 302, + 303, + 5, + 65, + 0, + 0, + 303, + 304, + 5, + 73, + 0, + 0, + 304, + 305, + 5, + 84, + 0, + 0, + 305, + 306, + 5, + 95, + 0, + 0, + 306, + 307, + 5, + 73, + 0, + 0, + 307, + 308, + 5, + 78, + 0, + 0, + 308, + 309, + 5, + 67, + 0, + 0, + 309, + 310, + 5, + 76, + 0, + 0, + 310, + 311, + 5, + 85, + 0, + 0, + 311, + 312, + 5, + 68, + 0, + 0, + 312, + 313, + 5, + 69, + 0, + 0, + 313, + 314, + 5, + 58, + 0, + 0, + 314, + 6, + 1, + 0, + 0, + 0, + 315, + 316, + 5, + 35, + 0, + 0, + 316, + 317, + 5, + 32, + 0, + 0, + 317, + 321, + 1, + 0, + 0, + 0, + 318, + 320, + 8, + 0, + 0, + 0, + 319, + 318, + 1, + 0, + 0, + 0, + 320, + 323, + 1, + 0, + 0, + 0, + 321, + 319, + 1, + 0, + 0, + 0, + 321, + 322, + 1, + 0, + 0, + 0, + 322, + 325, + 1, + 0, + 0, + 0, + 323, + 321, + 1, + 0, + 0, + 0, + 324, + 326, + 5, + 13, + 0, + 0, + 325, + 324, + 1, + 0, + 0, + 0, + 325, + 326, + 1, + 0, + 0, + 0, + 326, + 327, + 1, + 0, + 0, + 0, + 327, + 328, + 5, + 10, + 0, + 0, + 328, + 8, + 1, + 0, + 0, + 0, + 329, + 330, + 5, + 60, + 0, + 0, + 330, + 331, + 5, + 33, + 0, + 0, + 331, + 332, + 5, + 69, + 0, + 0, + 332, + 333, + 5, + 82, + 0, + 0, + 333, + 334, + 5, + 82, + 0, + 0, + 334, + 335, + 5, + 79, + 0, + 0, + 335, + 336, + 5, + 82, + 0, + 0, + 336, + 337, + 5, + 62, + 0, + 0, + 337, + 10, + 1, + 0, + 0, + 0, + 338, + 339, + 5, + 60, + 0, + 0, + 339, + 340, + 5, + 33, + 0, + 0, + 340, + 341, + 5, + 85, + 0, + 0, + 341, + 342, + 5, + 78, + 0, + 0, + 342, + 343, + 5, + 68, + 0, + 0, + 343, + 344, + 5, + 69, + 0, + 0, + 344, + 345, + 5, + 70, + 0, + 0, + 345, + 346, + 5, + 73, + 0, + 0, + 346, + 347, + 5, + 78, + 0, + 0, + 347, + 348, + 5, + 69, + 0, + 0, + 348, + 349, + 5, + 68, + 0, + 0, + 349, + 350, + 5, + 62, + 0, + 0, + 350, + 12, + 1, + 0, + 0, + 0, + 351, + 352, + 5, + 111, + 0, + 0, + 352, + 353, + 5, + 118, + 0, + 0, + 353, + 354, + 5, + 101, + 0, + 0, + 354, + 355, + 5, + 114, + 0, + 0, + 355, + 356, + 5, + 108, + 0, + 0, + 356, + 357, + 5, + 102, + 0, + 0, + 357, + 358, + 5, + 111, + 0, + 0, + 358, + 359, + 5, + 119, + 0, + 0, + 359, + 14, + 1, + 0, + 0, + 0, + 360, + 361, + 5, + 114, + 0, + 0, + 361, + 362, + 5, + 111, + 0, + 0, + 362, + 363, + 5, + 117, + 0, + 0, + 363, + 364, + 5, + 110, + 0, + 0, + 364, + 365, + 5, + 100, + 0, + 0, + 365, + 366, + 5, + 105, + 0, + 0, + 366, + 367, + 5, + 110, + 0, + 0, + 367, + 368, + 5, + 103, + 0, + 0, + 368, + 16, + 1, + 0, + 0, + 0, + 369, + 370, + 5, + 69, + 0, + 0, + 370, + 371, + 5, + 82, + 0, + 0, + 371, + 372, + 5, + 82, + 0, + 0, + 372, + 373, + 5, + 79, + 0, + 0, + 373, + 374, + 5, + 82, + 0, + 0, + 374, + 18, + 1, + 0, + 0, + 0, + 375, + 376, + 5, + 83, + 0, + 0, + 376, + 377, + 5, + 65, + 0, + 0, + 377, + 378, + 5, + 84, + 0, + 0, + 378, + 379, + 5, + 85, + 0, + 0, + 379, + 380, + 5, + 82, + 0, + 0, + 380, + 381, + 5, + 65, + 0, + 0, + 381, + 382, + 5, + 84, + 0, + 0, + 382, + 383, + 5, + 69, + 0, + 0, + 383, + 20, + 1, + 0, + 0, + 0, + 384, + 385, + 5, + 83, + 0, + 0, + 385, + 386, + 5, + 73, + 0, + 0, + 386, + 387, + 5, + 76, + 0, + 0, + 387, + 388, + 5, + 69, + 0, + 0, + 388, + 389, + 5, + 78, + 0, + 0, + 389, + 390, + 5, + 84, + 0, + 0, + 390, + 22, + 1, + 0, + 0, + 0, + 391, + 392, + 5, + 84, + 0, + 0, + 392, + 393, + 5, + 73, + 0, + 0, + 393, + 394, + 5, + 69, + 0, + 0, + 394, + 395, + 5, + 95, + 0, + 0, + 395, + 396, + 5, + 84, + 0, + 0, + 396, + 397, + 5, + 79, + 0, + 0, + 397, + 398, + 5, + 95, + 0, + 0, + 398, + 399, + 5, + 69, + 0, + 0, + 399, + 400, + 5, + 86, + 0, + 0, + 400, + 401, + 5, + 69, + 0, + 0, + 401, + 402, + 5, + 78, + 0, + 0, + 402, + 24, + 1, + 0, + 0, + 0, + 403, + 404, + 5, + 78, + 0, + 0, + 404, + 405, + 5, + 65, + 0, + 0, + 405, + 406, + 5, + 78, + 0, + 0, + 406, + 26, + 1, + 0, + 0, + 0, + 407, + 409, + 7, + 1, + 0, + 0, + 408, + 407, + 1, + 0, + 0, + 0, + 408, + 409, + 1, + 0, + 0, + 0, + 409, + 410, + 1, + 0, + 0, + 0, + 410, + 411, + 3, + 133, + 66, + 0, + 411, + 28, + 1, + 0, + 0, + 0, + 412, + 414, + 7, + 1, + 0, + 0, + 413, + 412, + 1, + 0, + 0, + 0, + 413, + 414, + 1, + 0, + 0, + 0, + 414, + 416, + 1, + 0, + 0, + 0, + 415, + 417, + 7, + 2, + 0, + 0, + 416, + 415, + 1, + 0, + 0, + 0, + 417, + 418, + 1, + 0, + 0, + 0, + 418, + 416, + 1, + 0, + 0, + 0, + 418, + 419, + 1, + 0, + 0, + 0, + 419, + 426, + 1, + 0, + 0, + 0, + 420, + 422, + 5, + 46, + 0, + 0, + 421, + 423, + 7, + 2, + 0, + 0, + 422, + 421, + 1, + 0, + 0, + 0, + 423, + 424, + 1, + 0, + 0, + 0, + 424, + 422, + 1, + 0, + 0, + 0, + 424, + 425, + 1, + 0, + 0, + 0, + 425, + 427, + 1, + 0, + 0, + 0, + 426, + 420, + 1, + 0, + 0, + 0, + 426, + 427, + 1, + 0, + 0, + 0, + 427, + 30, + 1, + 0, + 0, + 0, + 428, + 430, + 7, + 1, + 0, + 0, + 429, + 428, + 1, + 0, + 0, + 0, + 429, + 430, + 1, + 0, + 0, + 0, + 430, + 432, + 1, + 0, + 0, + 0, + 431, + 433, + 7, + 2, + 0, + 0, + 432, + 431, + 1, + 0, + 0, + 0, + 433, + 434, + 1, + 0, + 0, + 0, + 434, + 432, + 1, + 0, + 0, + 0, + 434, + 435, + 1, + 0, + 0, + 0, + 435, + 443, + 1, + 0, + 0, + 0, + 436, + 440, + 5, + 46, + 0, + 0, + 437, + 439, + 7, + 2, + 0, + 0, + 438, + 437, + 1, + 0, + 0, + 0, + 439, + 442, + 1, + 0, + 0, + 0, + 440, + 438, + 1, + 0, + 0, + 0, + 440, + 441, + 1, + 0, + 0, + 0, + 441, + 444, + 1, + 0, + 0, + 0, + 442, + 440, + 1, + 0, + 0, + 0, + 443, + 436, + 1, + 0, + 0, + 0, + 443, + 444, + 1, + 0, + 0, + 0, + 444, + 454, + 1, + 0, + 0, + 0, + 445, + 447, + 7, + 3, + 0, + 0, + 446, + 448, + 7, + 1, + 0, + 0, + 447, + 446, + 1, + 0, + 0, + 0, + 447, + 448, + 1, + 0, + 0, + 0, + 448, + 450, + 1, + 0, + 0, + 0, + 449, + 451, + 7, + 2, + 0, + 0, + 450, + 449, + 1, + 0, + 0, + 0, + 451, + 452, + 1, + 0, + 0, + 0, + 452, + 450, + 1, + 0, + 0, + 0, + 452, + 453, + 1, + 0, + 0, + 0, + 453, + 455, + 1, + 0, + 0, + 0, + 454, + 445, + 1, + 0, + 0, + 0, + 454, + 455, + 1, + 0, + 0, + 0, + 455, + 473, + 1, + 0, + 0, + 0, + 456, + 458, + 7, + 1, + 0, + 0, + 457, + 456, + 1, + 0, + 0, + 0, + 457, + 458, + 1, + 0, + 0, + 0, + 458, + 459, + 1, + 0, + 0, + 0, + 459, + 460, + 5, + 105, + 0, + 0, + 460, + 461, + 5, + 110, + 0, + 0, + 461, + 473, + 5, + 102, + 0, + 0, + 462, + 463, + 5, + 110, + 0, + 0, + 463, + 464, + 5, + 97, + 0, + 0, + 464, + 473, + 5, + 110, + 0, + 0, + 465, + 466, + 5, + 78, + 0, + 0, + 466, + 467, + 5, + 97, + 0, + 0, + 467, + 473, + 5, + 78, + 0, + 0, + 468, + 469, + 5, + 115, + 0, + 0, + 469, + 470, + 5, + 110, + 0, + 0, + 470, + 471, + 5, + 97, + 0, + 0, + 471, + 473, + 5, + 110, + 0, + 0, + 472, + 429, + 1, + 0, + 0, + 0, + 472, + 457, + 1, + 0, + 0, + 0, + 472, + 462, + 1, + 0, + 0, + 0, + 472, + 465, + 1, + 0, + 0, + 0, + 472, + 468, + 1, + 0, + 0, + 0, + 473, + 32, + 1, + 0, + 0, + 0, + 474, + 475, + 5, + 116, + 0, + 0, + 475, + 476, + 5, + 114, + 0, + 0, + 476, + 477, + 5, + 117, + 0, + 0, + 477, + 484, + 5, + 101, + 0, + 0, + 478, + 479, + 5, + 102, + 0, + 0, + 479, + 480, + 5, + 97, + 0, + 0, + 480, + 481, + 5, + 108, + 0, + 0, + 481, + 482, + 5, + 115, + 0, + 0, + 482, + 484, + 5, + 101, + 0, + 0, + 483, + 474, + 1, + 0, + 0, + 0, + 483, + 478, + 1, + 0, + 0, + 0, + 484, + 34, + 1, + 0, + 0, + 0, + 485, + 486, + 7, + 2, + 0, + 0, + 486, + 487, + 7, + 2, + 0, + 0, + 487, + 488, + 7, + 2, + 0, + 0, + 488, + 489, + 7, + 2, + 0, + 0, + 489, + 36, + 1, + 0, + 0, + 0, + 490, + 491, + 7, + 2, + 0, + 0, + 491, + 492, + 7, + 2, + 0, + 0, + 492, + 38, + 1, + 0, + 0, + 0, + 493, + 494, + 5, + 39, + 0, + 0, + 494, + 495, + 3, + 35, + 17, + 0, + 495, + 496, + 5, + 45, + 0, + 0, + 496, + 497, + 3, + 37, + 18, + 0, + 497, + 498, + 5, + 45, + 0, + 0, + 498, + 499, + 3, + 37, + 18, + 0, + 499, + 500, + 5, + 84, + 0, + 0, + 500, + 501, + 3, + 37, + 18, + 0, + 501, + 502, + 5, + 58, + 0, + 0, + 502, + 503, + 3, + 37, + 18, + 0, + 503, + 504, + 5, + 58, + 0, + 0, + 504, + 511, + 3, + 37, + 18, + 0, + 505, + 507, + 5, + 46, + 0, + 0, + 506, + 508, + 7, + 2, + 0, + 0, + 507, + 506, + 1, + 0, + 0, + 0, + 508, + 509, + 1, + 0, + 0, + 0, + 509, + 507, + 1, + 0, + 0, + 0, + 509, + 510, + 1, + 0, + 0, + 0, + 510, + 512, + 1, + 0, + 0, + 0, + 511, + 505, + 1, + 0, + 0, + 0, + 511, + 512, + 1, + 0, + 0, + 0, + 512, + 513, + 1, + 0, + 0, + 0, + 513, + 514, + 7, + 1, + 0, + 0, + 514, + 515, + 3, + 37, + 18, + 0, + 515, + 516, + 5, + 58, + 0, + 0, + 516, + 517, + 3, + 37, + 18, + 0, + 517, + 518, + 5, + 39, + 0, + 0, + 518, + 40, + 1, + 0, + 0, + 0, + 519, + 520, + 5, + 39, + 0, + 0, + 520, + 521, + 3, + 35, + 17, + 0, + 521, + 522, + 5, + 45, + 0, + 0, + 522, + 523, + 3, + 37, + 18, + 0, + 523, + 524, + 5, + 45, + 0, + 0, + 524, + 525, + 3, + 37, + 18, + 0, + 525, + 526, + 5, + 84, + 0, + 0, + 526, + 527, + 3, + 37, + 18, + 0, + 527, + 528, + 5, + 58, + 0, + 0, + 528, + 529, + 3, + 37, + 18, + 0, + 529, + 530, + 5, + 58, + 0, + 0, + 530, + 537, + 3, + 37, + 18, + 0, + 531, + 533, + 5, + 46, + 0, + 0, + 532, + 534, + 7, + 2, + 0, + 0, + 533, + 532, + 1, + 0, + 0, + 0, + 534, + 535, + 1, + 0, + 0, + 0, + 535, + 533, + 1, + 0, + 0, + 0, + 535, + 536, + 1, + 0, + 0, + 0, + 536, + 538, + 1, + 0, + 0, + 0, + 537, + 531, + 1, + 0, + 0, + 0, + 537, + 538, + 1, + 0, + 0, + 0, + 538, + 539, + 1, + 0, + 0, + 0, + 539, + 540, + 5, + 39, + 0, + 0, + 540, + 42, + 1, + 0, + 0, + 0, + 541, + 542, + 5, + 39, + 0, + 0, + 542, + 543, + 3, + 37, + 18, + 0, + 543, + 544, + 5, + 58, + 0, + 0, + 544, + 545, + 3, + 37, + 18, + 0, + 545, + 546, + 5, + 58, + 0, + 0, + 546, + 553, + 3, + 37, + 18, + 0, + 547, + 549, + 5, + 46, + 0, + 0, + 548, + 550, + 7, + 2, + 0, + 0, + 549, + 548, + 1, + 0, + 0, + 0, + 550, + 551, + 1, + 0, + 0, + 0, + 551, + 549, + 1, + 0, + 0, + 0, + 551, + 552, + 1, + 0, + 0, + 0, + 552, + 554, + 1, + 0, + 0, + 0, + 553, + 547, + 1, + 0, + 0, + 0, + 553, + 554, + 1, + 0, + 0, + 0, + 554, + 555, + 1, + 0, + 0, + 0, + 555, + 556, + 5, + 39, + 0, + 0, + 556, + 44, + 1, + 0, + 0, + 0, + 557, + 558, + 5, + 39, + 0, + 0, + 558, + 559, + 3, + 35, + 17, + 0, + 559, + 560, + 5, + 45, + 0, + 0, + 560, + 561, + 3, + 37, + 18, + 0, + 561, + 562, + 5, + 45, + 0, + 0, + 562, + 563, + 3, + 37, + 18, + 0, + 563, + 564, + 5, + 39, + 0, + 0, + 564, + 46, + 1, + 0, + 0, + 0, + 565, + 566, + 5, + 80, + 0, + 0, + 566, + 48, + 1, + 0, + 0, + 0, + 567, + 568, + 5, + 84, + 0, + 0, + 568, + 50, + 1, + 0, + 0, + 0, + 569, + 570, + 5, + 89, + 0, + 0, + 570, + 52, + 1, + 0, + 0, + 0, + 571, + 572, + 5, + 77, + 0, + 0, + 572, + 54, + 1, + 0, + 0, + 0, + 573, + 574, + 5, + 68, + 0, + 0, + 574, + 56, + 1, + 0, + 0, + 0, + 575, + 576, + 5, + 72, + 0, + 0, + 576, + 58, + 1, + 0, + 0, + 0, + 577, + 578, + 5, + 83, + 0, + 0, + 578, + 60, + 1, + 0, + 0, + 0, + 579, + 580, + 5, + 70, + 0, + 0, + 580, + 62, + 1, + 0, + 0, + 0, + 581, + 582, + 5, + 39, + 0, + 0, + 582, + 583, + 3, + 47, + 23, + 0, + 583, + 584, + 3, + 27, + 13, + 0, + 584, + 588, + 3, + 51, + 25, + 0, + 585, + 586, + 3, + 27, + 13, + 0, + 586, + 587, + 3, + 53, + 26, + 0, + 587, + 589, + 1, + 0, + 0, + 0, + 588, + 585, + 1, + 0, + 0, + 0, + 588, + 589, + 1, + 0, + 0, + 0, + 589, + 590, + 1, + 0, + 0, + 0, + 590, + 591, + 5, + 39, + 0, + 0, + 591, + 599, + 1, + 0, + 0, + 0, + 592, + 593, + 5, + 39, + 0, + 0, + 593, + 594, + 3, + 47, + 23, + 0, + 594, + 595, + 3, + 27, + 13, + 0, + 595, + 596, + 3, + 53, + 26, + 0, + 596, + 597, + 5, + 39, + 0, + 0, + 597, + 599, + 1, + 0, + 0, + 0, + 598, + 581, + 1, + 0, + 0, + 0, + 598, + 592, + 1, + 0, + 0, + 0, + 599, + 64, + 1, + 0, + 0, + 0, + 600, + 601, + 5, + 39, + 0, + 0, + 601, + 602, + 3, + 47, + 23, + 0, + 602, + 603, + 3, + 27, + 13, + 0, + 603, + 607, + 3, + 55, + 27, + 0, + 604, + 605, + 3, + 49, + 24, + 0, + 605, + 606, + 3, + 67, + 33, + 0, + 606, + 608, + 1, + 0, + 0, + 0, + 607, + 604, + 1, + 0, + 0, + 0, + 607, + 608, + 1, + 0, + 0, + 0, + 608, + 609, + 1, + 0, + 0, + 0, + 609, + 610, + 5, + 39, + 0, + 0, + 610, + 618, + 1, + 0, + 0, + 0, + 611, + 612, + 5, + 39, + 0, + 0, + 612, + 613, + 3, + 47, + 23, + 0, + 613, + 614, + 3, + 49, + 24, + 0, + 614, + 615, + 3, + 67, + 33, + 0, + 615, + 616, + 5, + 39, + 0, + 0, + 616, + 618, + 1, + 0, + 0, + 0, + 617, + 600, + 1, + 0, + 0, + 0, + 617, + 611, + 1, + 0, + 0, + 0, + 618, + 66, + 1, + 0, + 0, + 0, + 619, + 620, + 3, + 27, + 13, + 0, + 620, + 624, + 3, + 57, + 28, + 0, + 621, + 622, + 3, + 27, + 13, + 0, + 622, + 623, + 3, + 53, + 26, + 0, + 623, + 625, + 1, + 0, + 0, + 0, + 624, + 621, + 1, + 0, + 0, + 0, + 624, + 625, + 1, + 0, + 0, + 0, + 625, + 629, + 1, + 0, + 0, + 0, + 626, + 627, + 3, + 27, + 13, + 0, + 627, + 628, + 3, + 59, + 29, + 0, + 628, + 630, + 1, + 0, + 0, + 0, + 629, + 626, + 1, + 0, + 0, + 0, + 629, + 630, + 1, + 0, + 0, + 0, + 630, + 634, + 1, + 0, + 0, + 0, + 631, + 632, + 3, + 27, + 13, + 0, + 632, + 633, + 3, + 61, + 30, + 0, + 633, + 635, + 1, + 0, + 0, + 0, + 634, + 631, + 1, + 0, + 0, + 0, + 634, + 635, + 1, + 0, + 0, + 0, + 635, + 659, + 1, + 0, + 0, + 0, + 636, + 637, + 3, + 27, + 13, + 0, + 637, + 641, + 3, + 53, + 26, + 0, + 638, + 639, + 3, + 27, + 13, + 0, + 639, + 640, + 3, + 59, + 29, + 0, + 640, + 642, + 1, + 0, + 0, + 0, + 641, + 638, + 1, + 0, + 0, + 0, + 641, + 642, + 1, + 0, + 0, + 0, + 642, + 646, + 1, + 0, + 0, + 0, + 643, + 644, + 3, + 27, + 13, + 0, + 644, + 645, + 3, + 61, + 30, + 0, + 645, + 647, + 1, + 0, + 0, + 0, + 646, + 643, + 1, + 0, + 0, + 0, + 646, + 647, + 1, + 0, + 0, + 0, + 647, + 659, + 1, + 0, + 0, + 0, + 648, + 649, + 3, + 27, + 13, + 0, + 649, + 653, + 3, + 59, + 29, + 0, + 650, + 651, + 3, + 27, + 13, + 0, + 651, + 652, + 3, + 61, + 30, + 0, + 652, + 654, + 1, + 0, + 0, + 0, + 653, + 650, + 1, + 0, + 0, + 0, + 653, + 654, + 1, + 0, + 0, + 0, + 654, + 659, + 1, + 0, + 0, + 0, + 655, + 656, + 3, + 27, + 13, + 0, + 656, + 657, + 3, + 61, + 30, + 0, + 657, + 659, + 1, + 0, + 0, + 0, + 658, + 619, + 1, + 0, + 0, + 0, + 658, + 636, + 1, + 0, + 0, + 0, + 658, + 648, + 1, + 0, + 0, + 0, + 658, + 655, + 1, + 0, + 0, + 0, + 659, + 68, + 1, + 0, + 0, + 0, + 660, + 661, + 5, + 110, + 0, + 0, + 661, + 662, + 5, + 117, + 0, + 0, + 662, + 663, + 5, + 108, + 0, + 0, + 663, + 664, + 5, + 108, + 0, + 0, + 664, + 70, + 1, + 0, + 0, + 0, + 665, + 673, + 5, + 39, + 0, + 0, + 666, + 667, + 5, + 92, + 0, + 0, + 667, + 672, + 9, + 0, + 0, + 0, + 668, + 669, + 5, + 39, + 0, + 0, + 669, + 672, + 5, + 39, + 0, + 0, + 670, + 672, + 8, + 4, + 0, + 0, + 671, + 666, + 1, + 0, + 0, + 0, + 671, + 668, + 1, + 0, + 0, + 0, + 671, + 670, + 1, + 0, + 0, + 0, + 672, + 675, + 1, + 0, + 0, + 0, + 673, + 671, + 1, + 0, + 0, + 0, + 673, + 674, + 1, + 0, + 0, + 0, + 674, + 676, + 1, + 0, + 0, + 0, + 675, + 673, + 1, + 0, + 0, + 0, + 676, + 677, + 5, + 39, + 0, + 0, + 677, + 72, + 1, + 0, + 0, + 0, + 678, + 679, + 5, + 47, + 0, + 0, + 679, + 680, + 5, + 47, + 0, + 0, + 680, + 684, + 1, + 0, + 0, + 0, + 681, + 683, + 8, + 0, + 0, + 0, + 682, + 681, + 1, + 0, + 0, + 0, + 683, + 686, + 1, + 0, + 0, + 0, + 684, + 682, + 1, + 0, + 0, + 0, + 684, + 685, + 1, + 0, + 0, + 0, + 685, + 687, + 1, + 0, + 0, + 0, + 686, + 684, + 1, + 0, + 0, + 0, + 687, + 688, + 6, + 36, + 0, + 0, + 688, + 74, + 1, + 0, + 0, + 0, + 689, + 690, + 5, + 47, + 0, + 0, + 690, + 691, + 5, + 42, + 0, + 0, + 691, + 699, + 1, + 0, + 0, + 0, + 692, + 700, + 8, + 5, + 0, + 0, + 693, + 695, + 5, + 42, + 0, + 0, + 694, + 693, + 1, + 0, + 0, + 0, + 695, + 696, + 1, + 0, + 0, + 0, + 696, + 694, + 1, + 0, + 0, + 0, + 696, + 697, + 1, + 0, + 0, + 0, + 697, + 698, + 1, + 0, + 0, + 0, + 698, + 700, + 8, + 6, + 0, + 0, + 699, + 692, + 1, + 0, + 0, + 0, + 699, + 694, + 1, + 0, + 0, + 0, + 700, + 704, + 1, + 0, + 0, + 0, + 701, + 703, + 5, + 42, + 0, + 0, + 702, + 701, + 1, + 0, + 0, + 0, + 703, + 706, + 1, + 0, + 0, + 0, + 704, + 702, + 1, + 0, + 0, + 0, + 704, + 705, + 1, + 0, + 0, + 0, + 705, + 707, + 1, + 0, + 0, + 0, + 706, + 704, + 1, + 0, + 0, + 0, + 707, + 708, + 5, + 42, + 0, + 0, + 708, + 709, + 5, + 47, + 0, + 0, + 709, + 710, + 1, + 0, + 0, + 0, + 710, + 711, + 6, + 37, + 0, + 0, + 711, + 76, + 1, + 0, + 0, + 0, + 712, + 714, + 7, + 7, + 0, + 0, + 713, + 712, + 1, + 0, + 0, + 0, + 714, + 715, + 1, + 0, + 0, + 0, + 715, + 713, + 1, + 0, + 0, + 0, + 715, + 716, + 1, + 0, + 0, + 0, + 716, + 717, + 1, + 0, + 0, + 0, + 717, + 718, + 6, + 38, + 0, + 0, + 718, + 78, + 1, + 0, + 0, + 0, + 719, + 720, + 7, + 8, + 0, + 0, + 720, + 80, + 1, + 0, + 0, + 0, + 721, + 722, + 7, + 9, + 0, + 0, + 722, + 82, + 1, + 0, + 0, + 0, + 723, + 724, + 7, + 10, + 0, + 0, + 724, + 84, + 1, + 0, + 0, + 0, + 725, + 726, + 7, + 11, + 0, + 0, + 726, + 86, + 1, + 0, + 0, + 0, + 727, + 728, + 7, + 3, + 0, + 0, + 728, + 88, + 1, + 0, + 0, + 0, + 729, + 730, + 7, + 12, + 0, + 0, + 730, + 90, + 1, + 0, + 0, + 0, + 731, + 732, + 7, + 13, + 0, + 0, + 732, + 92, + 1, + 0, + 0, + 0, + 733, + 734, + 7, + 14, + 0, + 0, + 734, + 94, + 1, + 0, + 0, + 0, + 735, + 736, + 7, + 15, + 0, + 0, + 736, + 96, + 1, + 0, + 0, + 0, + 737, + 738, + 7, + 16, + 0, + 0, + 738, + 98, + 1, + 0, + 0, + 0, + 739, + 740, + 7, + 17, + 0, + 0, + 740, + 100, + 1, + 0, + 0, + 0, + 741, + 742, + 7, + 18, + 0, + 0, + 742, + 102, + 1, + 0, + 0, + 0, + 743, + 744, + 7, + 19, + 0, + 0, + 744, + 104, + 1, + 0, + 0, + 0, + 745, + 746, + 7, + 20, + 0, + 0, + 746, + 106, + 1, + 0, + 0, + 0, + 747, + 748, + 7, + 21, + 0, + 0, + 748, + 108, + 1, + 0, + 0, + 0, + 749, + 750, + 7, + 22, + 0, + 0, + 750, + 110, + 1, + 0, + 0, + 0, + 751, + 752, + 7, + 23, + 0, + 0, + 752, + 112, + 1, + 0, + 0, + 0, + 753, + 754, + 7, + 24, + 0, + 0, + 754, + 114, + 1, + 0, + 0, + 0, + 755, + 756, + 7, + 25, + 0, + 0, + 756, + 116, + 1, + 0, + 0, + 0, + 757, + 758, + 7, + 26, + 0, + 0, + 758, + 118, + 1, + 0, + 0, + 0, + 759, + 760, + 7, + 27, + 0, + 0, + 760, + 120, + 1, + 0, + 0, + 0, + 761, + 762, + 7, + 28, + 0, + 0, + 762, + 122, + 1, + 0, + 0, + 0, + 763, + 764, + 7, + 29, + 0, + 0, + 764, + 124, + 1, + 0, + 0, + 0, + 765, + 766, + 7, + 30, + 0, + 0, + 766, + 126, + 1, + 0, + 0, + 0, + 767, + 768, + 7, + 31, + 0, + 0, + 768, + 128, + 1, + 0, + 0, + 0, + 769, + 770, + 7, + 32, + 0, + 0, + 770, + 130, + 1, + 0, + 0, + 0, + 771, + 772, + 7, + 2, + 0, + 0, + 772, + 132, + 1, + 0, + 0, + 0, + 773, + 782, + 5, + 48, + 0, + 0, + 774, + 778, + 7, + 33, + 0, + 0, + 775, + 777, + 7, + 2, + 0, + 0, + 776, + 775, + 1, + 0, + 0, + 0, + 777, + 780, + 1, + 0, + 0, + 0, + 778, + 776, + 1, + 0, + 0, + 0, + 778, + 779, + 1, + 0, + 0, + 0, + 779, + 782, + 1, + 0, + 0, + 0, + 780, + 778, + 1, + 0, + 0, + 0, + 781, + 773, + 1, + 0, + 0, + 0, + 781, + 774, + 1, + 0, + 0, + 0, + 782, + 134, + 1, + 0, + 0, + 0, + 783, + 784, + 3, + 95, + 47, + 0, + 784, + 785, + 3, + 89, + 44, + 0, + 785, + 136, + 1, + 0, + 0, + 0, + 786, + 787, + 3, + 117, + 58, + 0, + 787, + 788, + 3, + 93, + 46, + 0, + 788, + 789, + 3, + 87, + 43, + 0, + 789, + 790, + 3, + 105, + 52, + 0, + 790, + 138, + 1, + 0, + 0, + 0, + 791, + 792, + 3, + 87, + 43, + 0, + 792, + 793, + 3, + 101, + 50, + 0, + 793, + 794, + 3, + 115, + 57, + 0, + 794, + 795, + 3, + 87, + 43, + 0, + 795, + 140, + 1, + 0, + 0, + 0, + 796, + 797, + 3, + 81, + 40, + 0, + 797, + 798, + 3, + 107, + 53, + 0, + 798, + 799, + 3, + 107, + 53, + 0, + 799, + 800, + 3, + 101, + 50, + 0, + 800, + 801, + 3, + 87, + 43, + 0, + 801, + 802, + 3, + 79, + 39, + 0, + 802, + 803, + 3, + 105, + 52, + 0, + 803, + 142, + 1, + 0, + 0, + 0, + 804, + 805, + 3, + 95, + 47, + 0, + 805, + 806, + 5, + 56, + 0, + 0, + 806, + 144, + 1, + 0, + 0, + 0, + 807, + 808, + 3, + 95, + 47, + 0, + 808, + 809, + 5, + 49, + 0, + 0, + 809, + 810, + 5, + 54, + 0, + 0, + 810, + 146, + 1, + 0, + 0, + 0, + 811, + 812, + 3, + 95, + 47, + 0, + 812, + 813, + 5, + 51, + 0, + 0, + 813, + 814, + 5, + 50, + 0, + 0, + 814, + 148, + 1, + 0, + 0, + 0, + 815, + 816, + 3, + 95, + 47, + 0, + 816, + 817, + 5, + 54, + 0, + 0, + 817, + 818, + 5, + 52, + 0, + 0, + 818, + 150, + 1, + 0, + 0, + 0, + 819, + 820, + 3, + 89, + 44, + 0, + 820, + 821, + 3, + 109, + 54, + 0, + 821, + 822, + 5, + 51, + 0, + 0, + 822, + 823, + 5, + 50, + 0, + 0, + 823, + 152, + 1, + 0, + 0, + 0, + 824, + 825, + 3, + 89, + 44, + 0, + 825, + 826, + 3, + 109, + 54, + 0, + 826, + 827, + 5, + 54, + 0, + 0, + 827, + 828, + 5, + 52, + 0, + 0, + 828, + 154, + 1, + 0, + 0, + 0, + 829, + 830, + 3, + 115, + 57, + 0, + 830, + 831, + 3, + 117, + 58, + 0, + 831, + 832, + 3, + 113, + 56, + 0, + 832, + 833, + 3, + 95, + 47, + 0, + 833, + 834, + 3, + 105, + 52, + 0, + 834, + 835, + 3, + 91, + 45, + 0, + 835, + 156, + 1, + 0, + 0, + 0, + 836, + 837, + 3, + 81, + 40, + 0, + 837, + 838, + 3, + 95, + 47, + 0, + 838, + 839, + 3, + 105, + 52, + 0, + 839, + 840, + 3, + 79, + 39, + 0, + 840, + 841, + 3, + 113, + 56, + 0, + 841, + 842, + 3, + 127, + 63, + 0, + 842, + 158, + 1, + 0, + 0, + 0, + 843, + 844, + 3, + 117, + 58, + 0, + 844, + 845, + 3, + 95, + 47, + 0, + 845, + 846, + 3, + 103, + 51, + 0, + 846, + 847, + 3, + 87, + 43, + 0, + 847, + 848, + 3, + 115, + 57, + 0, + 848, + 849, + 3, + 117, + 58, + 0, + 849, + 850, + 3, + 79, + 39, + 0, + 850, + 851, + 3, + 103, + 51, + 0, + 851, + 852, + 3, + 109, + 54, + 0, + 852, + 160, + 1, + 0, + 0, + 0, + 853, + 854, + 3, + 117, + 58, + 0, + 854, + 855, + 3, + 95, + 47, + 0, + 855, + 856, + 3, + 103, + 51, + 0, + 856, + 857, + 3, + 87, + 43, + 0, + 857, + 858, + 3, + 115, + 57, + 0, + 858, + 859, + 3, + 117, + 58, + 0, + 859, + 860, + 3, + 79, + 39, + 0, + 860, + 861, + 3, + 103, + 51, + 0, + 861, + 862, + 3, + 109, + 54, + 0, + 862, + 863, + 5, + 95, + 0, + 0, + 863, + 864, + 3, + 117, + 58, + 0, + 864, + 865, + 3, + 129, + 64, + 0, + 865, + 162, + 1, + 0, + 0, + 0, + 866, + 867, + 3, + 85, + 42, + 0, + 867, + 868, + 3, + 79, + 39, + 0, + 868, + 869, + 3, + 117, + 58, + 0, + 869, + 870, + 3, + 87, + 43, + 0, + 870, + 164, + 1, + 0, + 0, + 0, + 871, + 872, + 3, + 117, + 58, + 0, + 872, + 873, + 3, + 95, + 47, + 0, + 873, + 874, + 3, + 103, + 51, + 0, + 874, + 875, + 3, + 87, + 43, + 0, + 875, + 166, + 1, + 0, + 0, + 0, + 876, + 877, + 3, + 95, + 47, + 0, + 877, + 878, + 3, + 105, + 52, + 0, + 878, + 879, + 3, + 117, + 58, + 0, + 879, + 880, + 3, + 87, + 43, + 0, + 880, + 881, + 3, + 113, + 56, + 0, + 881, + 882, + 3, + 121, + 60, + 0, + 882, + 883, + 3, + 79, + 39, + 0, + 883, + 884, + 3, + 101, + 50, + 0, + 884, + 885, + 5, + 95, + 0, + 0, + 885, + 886, + 3, + 127, + 63, + 0, + 886, + 887, + 3, + 87, + 43, + 0, + 887, + 888, + 3, + 79, + 39, + 0, + 888, + 889, + 3, + 113, + 56, + 0, + 889, + 168, + 1, + 0, + 0, + 0, + 890, + 891, + 3, + 95, + 47, + 0, + 891, + 892, + 3, + 105, + 52, + 0, + 892, + 893, + 3, + 117, + 58, + 0, + 893, + 894, + 3, + 87, + 43, + 0, + 894, + 895, + 3, + 113, + 56, + 0, + 895, + 896, + 3, + 121, + 60, + 0, + 896, + 897, + 3, + 79, + 39, + 0, + 897, + 898, + 3, + 101, + 50, + 0, + 898, + 899, + 5, + 95, + 0, + 0, + 899, + 900, + 3, + 85, + 42, + 0, + 900, + 901, + 3, + 79, + 39, + 0, + 901, + 902, + 3, + 127, + 63, + 0, + 902, + 170, + 1, + 0, + 0, + 0, + 903, + 904, + 3, + 119, + 59, + 0, + 904, + 905, + 3, + 119, + 59, + 0, + 905, + 906, + 3, + 95, + 47, + 0, + 906, + 907, + 3, + 85, + 42, + 0, + 907, + 172, + 1, + 0, + 0, + 0, + 908, + 909, + 3, + 85, + 42, + 0, + 909, + 910, + 3, + 87, + 43, + 0, + 910, + 911, + 3, + 83, + 41, + 0, + 911, + 912, + 3, + 95, + 47, + 0, + 912, + 913, + 3, + 103, + 51, + 0, + 913, + 914, + 3, + 79, + 39, + 0, + 914, + 915, + 3, + 101, + 50, + 0, + 915, + 174, + 1, + 0, + 0, + 0, + 916, + 917, + 3, + 109, + 54, + 0, + 917, + 918, + 3, + 113, + 56, + 0, + 918, + 919, + 3, + 87, + 43, + 0, + 919, + 920, + 3, + 83, + 41, + 0, + 920, + 921, + 3, + 95, + 47, + 0, + 921, + 922, + 3, + 115, + 57, + 0, + 922, + 923, + 3, + 95, + 47, + 0, + 923, + 924, + 3, + 107, + 53, + 0, + 924, + 925, + 3, + 105, + 52, + 0, + 925, + 926, + 5, + 95, + 0, + 0, + 926, + 927, + 3, + 117, + 58, + 0, + 927, + 928, + 3, + 95, + 47, + 0, + 928, + 929, + 3, + 103, + 51, + 0, + 929, + 930, + 3, + 87, + 43, + 0, + 930, + 931, + 3, + 115, + 57, + 0, + 931, + 932, + 3, + 117, + 58, + 0, + 932, + 933, + 3, + 79, + 39, + 0, + 933, + 934, + 3, + 103, + 51, + 0, + 934, + 935, + 3, + 109, + 54, + 0, + 935, + 176, + 1, + 0, + 0, + 0, + 936, + 937, + 3, + 109, + 54, + 0, + 937, + 938, + 3, + 113, + 56, + 0, + 938, + 939, + 3, + 87, + 43, + 0, + 939, + 940, + 3, + 83, + 41, + 0, + 940, + 941, + 3, + 95, + 47, + 0, + 941, + 942, + 3, + 115, + 57, + 0, + 942, + 943, + 3, + 95, + 47, + 0, + 943, + 944, + 3, + 107, + 53, + 0, + 944, + 945, + 3, + 105, + 52, + 0, + 945, + 946, + 5, + 95, + 0, + 0, + 946, + 947, + 3, + 117, + 58, + 0, + 947, + 948, + 3, + 95, + 47, + 0, + 948, + 949, + 3, + 103, + 51, + 0, + 949, + 950, + 3, + 87, + 43, + 0, + 950, + 951, + 3, + 115, + 57, + 0, + 951, + 952, + 3, + 117, + 58, + 0, + 952, + 953, + 3, + 79, + 39, + 0, + 953, + 954, + 3, + 103, + 51, + 0, + 954, + 955, + 3, + 109, + 54, + 0, + 955, + 956, + 5, + 95, + 0, + 0, + 956, + 957, + 3, + 117, + 58, + 0, + 957, + 958, + 3, + 129, + 64, + 0, + 958, + 178, + 1, + 0, + 0, + 0, + 959, + 960, + 3, + 89, + 44, + 0, + 960, + 961, + 3, + 95, + 47, + 0, + 961, + 962, + 3, + 125, + 62, + 0, + 962, + 963, + 3, + 87, + 43, + 0, + 963, + 964, + 3, + 85, + 42, + 0, + 964, + 965, + 3, + 83, + 41, + 0, + 965, + 966, + 3, + 93, + 46, + 0, + 966, + 967, + 3, + 79, + 39, + 0, + 967, + 968, + 3, + 113, + 56, + 0, + 968, + 180, + 1, + 0, + 0, + 0, + 969, + 970, + 3, + 121, + 60, + 0, + 970, + 971, + 3, + 79, + 39, + 0, + 971, + 972, + 3, + 113, + 56, + 0, + 972, + 973, + 3, + 83, + 41, + 0, + 973, + 974, + 3, + 93, + 46, + 0, + 974, + 975, + 3, + 79, + 39, + 0, + 975, + 976, + 3, + 113, + 56, + 0, + 976, + 182, + 1, + 0, + 0, + 0, + 977, + 978, + 3, + 89, + 44, + 0, + 978, + 979, + 3, + 95, + 47, + 0, + 979, + 980, + 3, + 125, + 62, + 0, + 980, + 981, + 3, + 87, + 43, + 0, + 981, + 982, + 3, + 85, + 42, + 0, + 982, + 983, + 3, + 81, + 40, + 0, + 983, + 984, + 3, + 95, + 47, + 0, + 984, + 985, + 3, + 105, + 52, + 0, + 985, + 986, + 3, + 79, + 39, + 0, + 986, + 987, + 3, + 113, + 56, + 0, + 987, + 988, + 3, + 127, + 63, + 0, + 988, + 184, + 1, + 0, + 0, + 0, + 989, + 990, + 3, + 115, + 57, + 0, + 990, + 991, + 3, + 117, + 58, + 0, + 991, + 992, + 3, + 113, + 56, + 0, + 992, + 993, + 3, + 119, + 59, + 0, + 993, + 994, + 3, + 83, + 41, + 0, + 994, + 995, + 3, + 117, + 58, + 0, + 995, + 186, + 1, + 0, + 0, + 0, + 996, + 997, + 3, + 105, + 52, + 0, + 997, + 998, + 3, + 115, + 57, + 0, + 998, + 999, + 3, + 117, + 58, + 0, + 999, + 1000, + 3, + 113, + 56, + 0, + 1000, + 1001, + 3, + 119, + 59, + 0, + 1001, + 1002, + 3, + 83, + 41, + 0, + 1002, + 1003, + 3, + 117, + 58, + 0, + 1003, + 188, + 1, + 0, + 0, + 0, + 1004, + 1005, + 3, + 101, + 50, + 0, + 1005, + 1006, + 3, + 95, + 47, + 0, + 1006, + 1007, + 3, + 115, + 57, + 0, + 1007, + 1008, + 3, + 117, + 58, + 0, + 1008, + 190, + 1, + 0, + 0, + 0, + 1009, + 1010, + 3, + 103, + 51, + 0, + 1010, + 1011, + 3, + 79, + 39, + 0, + 1011, + 1012, + 3, + 109, + 54, + 0, + 1012, + 192, + 1, + 0, + 0, + 0, + 1013, + 1014, + 3, + 79, + 39, + 0, + 1014, + 1015, + 3, + 105, + 52, + 0, + 1015, + 1016, + 3, + 127, + 63, + 0, + 1016, + 194, + 1, + 0, + 0, + 0, + 1017, + 1018, + 3, + 119, + 59, + 0, + 1018, + 1019, + 5, + 33, + 0, + 0, + 1019, + 196, + 1, + 0, + 0, + 0, + 1020, + 1021, + 3, + 81, + 40, + 0, + 1021, + 1022, + 3, + 107, + 53, + 0, + 1022, + 1023, + 3, + 107, + 53, + 0, + 1023, + 1024, + 3, + 101, + 50, + 0, + 1024, + 198, + 1, + 0, + 0, + 0, + 1025, + 1026, + 3, + 115, + 57, + 0, + 1026, + 1027, + 3, + 117, + 58, + 0, + 1027, + 1028, + 3, + 113, + 56, + 0, + 1028, + 200, + 1, + 0, + 0, + 0, + 1029, + 1030, + 3, + 121, + 60, + 0, + 1030, + 1031, + 3, + 81, + 40, + 0, + 1031, + 1032, + 3, + 95, + 47, + 0, + 1032, + 1033, + 3, + 105, + 52, + 0, + 1033, + 202, + 1, + 0, + 0, + 0, + 1034, + 1035, + 3, + 117, + 58, + 0, + 1035, + 1036, + 3, + 115, + 57, + 0, + 1036, + 204, + 1, + 0, + 0, + 0, + 1037, + 1038, + 3, + 117, + 58, + 0, + 1038, + 1039, + 3, + 115, + 57, + 0, + 1039, + 1040, + 3, + 117, + 58, + 0, + 1040, + 1041, + 3, + 129, + 64, + 0, + 1041, + 206, + 1, + 0, + 0, + 0, + 1042, + 1043, + 3, + 95, + 47, + 0, + 1043, + 1044, + 3, + 127, + 63, + 0, + 1044, + 1045, + 3, + 87, + 43, + 0, + 1045, + 1046, + 3, + 79, + 39, + 0, + 1046, + 1047, + 3, + 113, + 56, + 0, + 1047, + 208, + 1, + 0, + 0, + 0, + 1048, + 1049, + 3, + 95, + 47, + 0, + 1049, + 1050, + 3, + 85, + 42, + 0, + 1050, + 1051, + 3, + 79, + 39, + 0, + 1051, + 1052, + 3, + 127, + 63, + 0, + 1052, + 210, + 1, + 0, + 0, + 0, + 1053, + 1054, + 3, + 85, + 42, + 0, + 1054, + 1055, + 3, + 87, + 43, + 0, + 1055, + 1056, + 3, + 83, + 41, + 0, + 1056, + 212, + 1, + 0, + 0, + 0, + 1057, + 1058, + 3, + 109, + 54, + 0, + 1058, + 1059, + 3, + 117, + 58, + 0, + 1059, + 1060, + 3, + 115, + 57, + 0, + 1060, + 214, + 1, + 0, + 0, + 0, + 1061, + 1062, + 3, + 109, + 54, + 0, + 1062, + 1063, + 3, + 117, + 58, + 0, + 1063, + 1064, + 3, + 115, + 57, + 0, + 1064, + 1065, + 3, + 117, + 58, + 0, + 1065, + 1066, + 3, + 129, + 64, + 0, + 1066, + 216, + 1, + 0, + 0, + 0, + 1067, + 1068, + 3, + 89, + 44, + 0, + 1068, + 1069, + 3, + 83, + 41, + 0, + 1069, + 1070, + 3, + 93, + 46, + 0, + 1070, + 1071, + 3, + 79, + 39, + 0, + 1071, + 1072, + 3, + 113, + 56, + 0, + 1072, + 218, + 1, + 0, + 0, + 0, + 1073, + 1074, + 3, + 121, + 60, + 0, + 1074, + 1075, + 3, + 83, + 41, + 0, + 1075, + 1076, + 3, + 93, + 46, + 0, + 1076, + 1077, + 3, + 79, + 39, + 0, + 1077, + 1078, + 3, + 113, + 56, + 0, + 1078, + 220, + 1, + 0, + 0, + 0, + 1079, + 1080, + 3, + 89, + 44, + 0, + 1080, + 1081, + 3, + 81, + 40, + 0, + 1081, + 1082, + 3, + 95, + 47, + 0, + 1082, + 1083, + 3, + 105, + 52, + 0, + 1083, + 222, + 1, + 0, + 0, + 0, + 1084, + 1085, + 5, + 58, + 0, + 0, + 1085, + 1086, + 5, + 58, + 0, + 0, + 1086, + 224, + 1, + 0, + 0, + 0, + 1087, + 1091, + 7, + 34, + 0, + 0, + 1088, + 1090, + 7, + 35, + 0, + 0, + 1089, + 1088, + 1, + 0, + 0, + 0, + 1090, + 1093, + 1, + 0, + 0, + 0, + 1091, + 1089, + 1, + 0, + 0, + 0, + 1091, + 1092, + 1, + 0, + 0, + 0, + 1092, + 226, + 1, + 0, + 0, + 0, + 1093, + 1091, + 1, + 0, + 0, + 0, + 1094, + 1095, + 5, + 60, + 0, + 0, + 1095, + 228, + 1, + 0, + 0, + 0, + 1096, + 1097, + 5, + 62, + 0, + 0, + 1097, + 230, + 1, + 0, + 0, + 0, + 1098, + 1099, + 5, + 40, + 0, + 0, + 1099, + 232, + 1, + 0, + 0, + 0, + 1100, + 1101, + 5, + 41, + 0, + 0, + 1101, + 234, + 1, + 0, + 0, + 0, + 1102, + 1103, + 5, + 91, + 0, + 0, + 1103, + 236, + 1, + 0, + 0, + 0, + 1104, + 1105, + 5, + 93, + 0, + 0, + 1105, + 238, + 1, + 0, + 0, + 0, + 1106, + 1107, + 5, + 44, + 0, + 0, + 1107, + 240, + 1, + 0, + 0, + 0, + 1108, + 1109, + 5, + 61, + 0, + 0, + 1109, + 242, + 1, + 0, + 0, + 0, + 1110, + 1111, + 5, + 58, + 0, + 0, + 1111, + 244, + 1, + 0, + 0, + 0, + 1112, + 1113, + 5, + 63, + 0, + 0, + 1113, + 246, + 1, + 0, + 0, + 0, + 1114, + 1115, + 5, + 35, + 0, + 0, + 1115, + 248, + 1, + 0, + 0, + 0, + 1116, + 1117, + 5, + 46, + 0, + 0, + 1117, + 250, + 1, + 0, + 0, + 0, + 48, + 0, + 282, + 288, + 290, + 321, + 325, + 408, + 413, + 418, + 424, + 426, + 429, + 434, + 440, + 443, + 447, + 452, + 454, + 457, + 472, + 483, + 509, + 511, + 535, + 537, + 551, + 553, + 588, + 598, + 607, + 617, + 624, + 629, + 634, + 641, + 646, + 653, + 658, + 671, + 673, + 684, + 696, + 699, + 704, + 715, + 778, + 781, + 1091, + 1, + 0, + 1, + 0, ] + class TestFileLexer(Lexer): atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] SUBSTRAIT_SCALAR_TEST = 1 FORMAT_VERSION = 2 @@ -524,70 +9781,280 @@ class TestFileLexer(Lexer): HASH = 93 DOT = 94 - channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] - modeNames = [ "DEFAULT_MODE" ] + modeNames = ["DEFAULT_MODE"] - literalNames = [ "", - "'### SUBSTRAIT_SCALAR_TEST:'", "'### SUBSTRAIT_INCLUDE:'", - "''", "''", "'overlfow'", "'rounding'", - "'ERROR'", "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", - "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", "'null'", - "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", - "':'", "'?'", "'#'", "'.'" ] + literalNames = [ + "", + "'### SUBSTRAIT_SCALAR_TEST:'", + "'### SUBSTRAIT_INCLUDE:'", + "''", + "''", + "'overlfow'", + "'rounding'", + "'ERROR'", + "'SATURATE'", + "'SILENT'", + "'TIE_TO_EVEN'", + "'NAN'", + "'P'", + "'T'", + "'Y'", + "'M'", + "'D'", + "'H'", + "'S'", + "'F'", + "'null'", + "'::'", + "'<'", + "'>'", + "'('", + "')'", + "'['", + "']'", + "','", + "'='", + "':'", + "'?'", + "'#'", + "'.'", + ] - symbolicNames = [ "", - "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", - "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", "OVERFLOW", - "ROUNDING", "ERROR", "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", - "INTEGER_LITERAL", "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", - "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", - "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", - "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", "FRACTIONAL_SECOND_SUFFIX", - "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", "NULL_LITERAL", - "STRING_LITERAL", "LineComment", "BlockComment", "Whitespace", - "If", "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", - "FP32", "FP64", "String", "Binary", "Timestamp", "TimestampTZ", - "Date", "Time", "IntervalYear", "IntervalDay", "UUID", "Decimal", - "PrecisionTimestamp", "PrecisionTimestampTZ", "FixedChar", "VarChar", - "FixedBinary", "Struct", "NStruct", "List", "Map", "ANY", "UserDefined", - "Bool", "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", - "PTs", "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", - "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", "CPAREN", "OBRACKET", - "CBRACKET", "COMMA", "EQ", "COLON", "QMARK", "HASH", "DOT" ] + symbolicNames = [ + "", + "SUBSTRAIT_SCALAR_TEST", + "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", + "ERROR_RESULT", + "UNDEFINED_RESULT", + "OVERFLOW", + "ROUNDING", + "ERROR", + "SATURATE", + "SILENT", + "TIE_TO_EVEN", + "NAN", + "INTEGER_LITERAL", + "DECIMAL_LITERAL", + "FLOAT_LITERAL", + "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", + "TIMESTAMP_LITERAL", + "TIME_LITERAL", + "DATE_LITERAL", + "PERIOD_PREFIX", + "TIME_PREFIX", + "YEAR_SUFFIX", + "M_SUFFIX", + "DAY_SUFFIX", + "HOUR_SUFFIX", + "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", + "NULL_LITERAL", + "STRING_LITERAL", + "LineComment", + "BlockComment", + "Whitespace", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "TimestampTZ", + "Date", + "Time", + "IntervalYear", + "IntervalDay", + "UUID", + "Decimal", + "PrecisionTimestamp", + "PrecisionTimestampTZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] - ruleNames = [ "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", - "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", - "OVERFLOW", "ROUNDING", "ERROR", "SATURATE", "SILENT", - "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", "DECIMAL_LITERAL", - "FLOAT_LITERAL", "BOOLEAN_LITERAL", "FourDigits", "TwoDigits", - "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", - "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", - "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", - "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", - "TIME_INTERVAL", "NULL_LITERAL", "STRING_LITERAL", "LineComment", - "BlockComment", "Whitespace", "A", "B", "C", "D", "E", - "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", - "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "DIGIT", - "INTEGER", "If", "Then", "Else", "Boolean", "I8", "I16", - "I32", "I64", "FP32", "FP64", "String", "Binary", "Timestamp", - "TimestampTZ", "Date", "Time", "IntervalYear", "IntervalDay", - "UUID", "Decimal", "PrecisionTimestamp", "PrecisionTimestampTZ", - "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", - "List", "Map", "ANY", "UserDefined", "Bool", "Str", "VBin", - "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", - "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", - "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", "CPAREN", - "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", "QMARK", - "HASH", "DOT" ] + ruleNames = [ + "SUBSTRAIT_SCALAR_TEST", + "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", + "ERROR_RESULT", + "UNDEFINED_RESULT", + "OVERFLOW", + "ROUNDING", + "ERROR", + "SATURATE", + "SILENT", + "TIE_TO_EVEN", + "NAN", + "INTEGER_LITERAL", + "DECIMAL_LITERAL", + "FLOAT_LITERAL", + "BOOLEAN_LITERAL", + "FourDigits", + "TwoDigits", + "TIMESTAMP_TZ_LITERAL", + "TIMESTAMP_LITERAL", + "TIME_LITERAL", + "DATE_LITERAL", + "PERIOD_PREFIX", + "TIME_PREFIX", + "YEAR_SUFFIX", + "M_SUFFIX", + "DAY_SUFFIX", + "HOUR_SUFFIX", + "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", + "TIME_INTERVAL", + "NULL_LITERAL", + "STRING_LITERAL", + "LineComment", + "BlockComment", + "Whitespace", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "DIGIT", + "INTEGER", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "TimestampTZ", + "Date", + "Time", + "IntervalYear", + "IntervalDay", + "UUID", + "Decimal", + "PrecisionTimestamp", + "PrecisionTimestampTZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] grammarFileName = "TestFileLexer.g4" - def __init__(self, input=None, output:TextIO = sys.stdout): + def __init__(self, input=None, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") - self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._interp = LexerATNSimulator( + self, self.atn, self.decisionsToDFA, PredictionContextCache() + ) self._actions = None self._predicates = None - - diff --git a/tests/coverage/antlr_parser/TestFileParser.py b/tests/coverage/antlr_parser/TestFileParser.py index f1d5e70c7..8d19f2d16 100644 --- a/tests/coverage/antlr_parser/TestFileParser.py +++ b/tests/coverage/antlr_parser/TestFileParser.py @@ -3,210 +3,3628 @@ from antlr4 import * from io import StringIO import sys + if sys.version_info[1] > 5: - from typing import TextIO + from typing import TextIO else: - from typing.io import TextIO + from typing.io import TextIO + def serializedATN(): return [ - 4,1,94,395,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, - 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13, - 2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20, - 7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26, - 2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33, - 7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39, - 2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,1,0,1,0,4,0,93, - 8,0,11,0,12,0,94,1,0,1,0,1,1,1,1,1,1,1,2,1,2,1,2,1,3,1,3,1,3,1,3, - 5,3,109,8,3,10,3,12,3,112,9,3,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1, - 5,1,5,3,5,124,8,5,1,5,1,5,1,5,1,6,1,6,4,6,131,8,6,11,6,12,6,132, - 1,7,1,7,1,7,5,7,138,8,7,10,7,12,7,141,9,7,1,8,1,8,3,8,145,8,8,1, - 9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3, - 9,163,8,9,1,10,1,10,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13, - 1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16, - 1,16,1,16,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,19,1,19,1,19, - 1,19,1,20,1,20,1,20,1,20,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22, - 1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,26, - 1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,3,27,237,8,27,1,27, - 1,27,1,27,3,27,242,8,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,250,8, - 28,1,28,1,28,1,28,3,28,255,8,28,1,29,1,29,1,29,1,29,3,29,261,8,29, - 1,29,1,29,3,29,265,8,29,1,29,1,29,3,29,269,8,29,1,29,1,29,1,29,1, - 29,3,29,275,8,29,1,29,1,29,3,29,279,8,29,1,29,1,29,1,29,1,29,3,29, - 285,8,29,1,29,1,29,3,29,289,8,29,1,30,1,30,3,30,293,8,30,1,31,1, - 31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1, - 31,1,31,1,31,1,31,3,31,313,8,31,1,32,1,32,3,32,317,8,32,1,32,1,32, - 1,32,1,32,1,33,1,33,3,33,325,8,33,1,33,1,33,1,33,1,33,1,34,1,34, - 3,34,333,8,34,1,34,1,34,1,34,1,34,1,35,1,35,3,35,341,8,35,1,35,1, - 35,1,35,1,35,1,35,1,35,3,35,349,8,35,1,36,1,36,3,36,353,8,36,1,36, - 1,36,1,36,1,36,1,37,1,37,3,37,361,8,37,1,37,1,37,1,37,1,37,1,38, - 1,38,1,38,1,38,1,38,1,38,3,38,373,8,38,1,39,1,39,1,40,1,40,1,41, - 1,41,1,41,1,41,1,42,1,42,1,43,1,43,1,44,1,44,1,44,5,44,390,8,44, - 10,44,12,44,393,9,44,1,44,0,0,45,0,2,4,6,8,10,12,14,16,18,20,22, - 24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66, - 68,70,72,74,76,78,80,82,84,86,88,0,4,1,0,14,16,1,0,5,6,2,0,7,8,82, - 82,1,0,9,13,413,0,90,1,0,0,0,2,98,1,0,0,0,4,101,1,0,0,0,6,104,1, - 0,0,0,8,113,1,0,0,0,10,115,1,0,0,0,12,128,1,0,0,0,14,134,1,0,0,0, - 16,144,1,0,0,0,18,162,1,0,0,0,20,164,1,0,0,0,22,166,1,0,0,0,24,170, - 1,0,0,0,26,174,1,0,0,0,28,178,1,0,0,0,30,182,1,0,0,0,32,186,1,0, - 0,0,34,190,1,0,0,0,36,194,1,0,0,0,38,198,1,0,0,0,40,202,1,0,0,0, - 42,206,1,0,0,0,44,210,1,0,0,0,46,214,1,0,0,0,48,218,1,0,0,0,50,222, - 1,0,0,0,52,226,1,0,0,0,54,241,1,0,0,0,56,254,1,0,0,0,58,288,1,0, - 0,0,60,292,1,0,0,0,62,312,1,0,0,0,64,314,1,0,0,0,66,322,1,0,0,0, - 68,330,1,0,0,0,70,338,1,0,0,0,72,350,1,0,0,0,74,358,1,0,0,0,76,372, - 1,0,0,0,78,374,1,0,0,0,80,376,1,0,0,0,82,378,1,0,0,0,84,382,1,0, - 0,0,86,384,1,0,0,0,88,386,1,0,0,0,90,92,3,2,1,0,91,93,3,12,6,0,92, - 91,1,0,0,0,93,94,1,0,0,0,94,92,1,0,0,0,94,95,1,0,0,0,95,96,1,0,0, - 0,96,97,5,0,0,1,97,1,1,0,0,0,98,99,3,4,2,0,99,100,3,6,3,0,100,3, - 1,0,0,0,101,102,5,1,0,0,102,103,5,2,0,0,103,5,1,0,0,0,104,105,5, - 3,0,0,105,110,5,33,0,0,106,107,5,89,0,0,107,109,5,33,0,0,108,106, - 1,0,0,0,109,112,1,0,0,0,110,108,1,0,0,0,110,111,1,0,0,0,111,7,1, - 0,0,0,112,110,1,0,0,0,113,114,5,4,0,0,114,9,1,0,0,0,115,116,5,82, - 0,0,116,117,5,85,0,0,117,118,3,14,7,0,118,123,5,86,0,0,119,120,5, - 87,0,0,120,121,3,88,44,0,121,122,5,88,0,0,122,124,1,0,0,0,123,119, - 1,0,0,0,123,124,1,0,0,0,124,125,1,0,0,0,125,126,5,90,0,0,126,127, - 3,16,8,0,127,11,1,0,0,0,128,130,3,8,4,0,129,131,3,10,5,0,130,129, - 1,0,0,0,131,132,1,0,0,0,132,130,1,0,0,0,132,133,1,0,0,0,133,13,1, - 0,0,0,134,139,3,18,9,0,135,136,5,89,0,0,136,138,3,18,9,0,137,135, - 1,0,0,0,138,141,1,0,0,0,139,137,1,0,0,0,139,140,1,0,0,0,140,15,1, - 0,0,0,141,139,1,0,0,0,142,145,3,18,9,0,143,145,3,80,40,0,144,142, - 1,0,0,0,144,143,1,0,0,0,145,17,1,0,0,0,146,163,3,22,11,0,147,163, - 3,24,12,0,148,163,3,26,13,0,149,163,3,28,14,0,150,163,3,30,15,0, - 151,163,3,32,16,0,152,163,3,34,17,0,153,163,3,38,19,0,154,163,3, - 40,20,0,155,163,3,36,18,0,156,163,3,42,21,0,157,163,3,44,22,0,158, - 163,3,46,23,0,159,163,3,48,24,0,160,163,3,50,25,0,161,163,3,52,26, - 0,162,146,1,0,0,0,162,147,1,0,0,0,162,148,1,0,0,0,162,149,1,0,0, - 0,162,150,1,0,0,0,162,151,1,0,0,0,162,152,1,0,0,0,162,153,1,0,0, - 0,162,154,1,0,0,0,162,155,1,0,0,0,162,156,1,0,0,0,162,157,1,0,0, - 0,162,158,1,0,0,0,162,159,1,0,0,0,162,160,1,0,0,0,162,161,1,0,0, - 0,163,19,1,0,0,0,164,165,7,0,0,0,165,21,1,0,0,0,166,167,5,32,0,0, - 167,168,5,81,0,0,168,169,3,60,30,0,169,23,1,0,0,0,170,171,5,14,0, - 0,171,172,5,81,0,0,172,173,5,41,0,0,173,25,1,0,0,0,174,175,5,14, - 0,0,175,176,5,81,0,0,176,177,5,42,0,0,177,27,1,0,0,0,178,179,5,14, - 0,0,179,180,5,81,0,0,180,181,5,43,0,0,181,29,1,0,0,0,182,183,5,14, - 0,0,183,184,5,81,0,0,184,185,5,44,0,0,185,31,1,0,0,0,186,187,3,20, - 10,0,187,188,5,81,0,0,188,189,5,45,0,0,189,33,1,0,0,0,190,191,3, - 20,10,0,191,192,5,81,0,0,192,193,5,46,0,0,193,35,1,0,0,0,194,195, - 3,20,10,0,195,196,5,81,0,0,196,197,3,70,35,0,197,37,1,0,0,0,198, - 199,5,17,0,0,199,200,5,81,0,0,200,201,5,68,0,0,201,39,1,0,0,0,202, - 203,5,33,0,0,203,204,5,81,0,0,204,205,5,69,0,0,205,41,1,0,0,0,206, - 207,5,21,0,0,207,208,5,81,0,0,208,209,5,51,0,0,209,43,1,0,0,0,210, - 211,5,20,0,0,211,212,5,81,0,0,212,213,5,52,0,0,213,45,1,0,0,0,214, - 215,5,19,0,0,215,216,5,81,0,0,216,217,5,71,0,0,217,47,1,0,0,0,218, - 219,5,18,0,0,219,220,5,81,0,0,220,221,5,72,0,0,221,49,1,0,0,0,222, - 223,5,30,0,0,223,224,5,81,0,0,224,225,5,73,0,0,225,51,1,0,0,0,226, - 227,5,31,0,0,227,228,5,81,0,0,228,229,5,74,0,0,229,53,1,0,0,0,230, - 231,5,22,0,0,231,232,5,14,0,0,232,233,5,24,0,0,233,236,1,0,0,0,234, - 235,5,14,0,0,235,237,5,25,0,0,236,234,1,0,0,0,236,237,1,0,0,0,237, - 242,1,0,0,0,238,239,5,22,0,0,239,240,5,14,0,0,240,242,5,25,0,0,241, - 230,1,0,0,0,241,238,1,0,0,0,242,55,1,0,0,0,243,244,5,22,0,0,244, - 245,5,14,0,0,245,246,5,26,0,0,246,249,1,0,0,0,247,248,5,23,0,0,248, - 250,3,58,29,0,249,247,1,0,0,0,249,250,1,0,0,0,250,255,1,0,0,0,251, - 252,5,22,0,0,252,253,5,23,0,0,253,255,3,58,29,0,254,243,1,0,0,0, - 254,251,1,0,0,0,255,57,1,0,0,0,256,257,5,14,0,0,257,260,5,27,0,0, - 258,259,5,14,0,0,259,261,5,25,0,0,260,258,1,0,0,0,260,261,1,0,0, - 0,261,264,1,0,0,0,262,263,5,14,0,0,263,265,5,28,0,0,264,262,1,0, - 0,0,264,265,1,0,0,0,265,268,1,0,0,0,266,267,5,14,0,0,267,269,5,29, - 0,0,268,266,1,0,0,0,268,269,1,0,0,0,269,289,1,0,0,0,270,271,5,14, - 0,0,271,274,5,25,0,0,272,273,5,14,0,0,273,275,5,28,0,0,274,272,1, - 0,0,0,274,275,1,0,0,0,275,278,1,0,0,0,276,277,5,14,0,0,277,279,5, - 29,0,0,278,276,1,0,0,0,278,279,1,0,0,0,279,289,1,0,0,0,280,281,5, - 14,0,0,281,284,5,28,0,0,282,283,5,14,0,0,283,285,5,29,0,0,284,282, - 1,0,0,0,284,285,1,0,0,0,285,289,1,0,0,0,286,287,5,14,0,0,287,289, - 5,29,0,0,288,256,1,0,0,0,288,270,1,0,0,0,288,280,1,0,0,0,288,286, - 1,0,0,0,289,59,1,0,0,0,290,293,3,62,31,0,291,293,3,76,38,0,292,290, - 1,0,0,0,292,291,1,0,0,0,293,61,1,0,0,0,294,313,5,68,0,0,295,313, - 5,41,0,0,296,313,5,42,0,0,297,313,5,43,0,0,298,313,5,44,0,0,299, - 313,5,45,0,0,300,313,5,46,0,0,301,313,5,69,0,0,302,313,5,48,0,0, - 303,313,5,71,0,0,304,313,5,72,0,0,305,313,5,51,0,0,306,313,5,52, - 0,0,307,313,5,74,0,0,308,313,5,73,0,0,309,313,5,55,0,0,310,311,5, - 67,0,0,311,313,5,82,0,0,312,294,1,0,0,0,312,295,1,0,0,0,312,296, - 1,0,0,0,312,297,1,0,0,0,312,298,1,0,0,0,312,299,1,0,0,0,312,300, - 1,0,0,0,312,301,1,0,0,0,312,302,1,0,0,0,312,303,1,0,0,0,312,304, - 1,0,0,0,312,305,1,0,0,0,312,306,1,0,0,0,312,307,1,0,0,0,312,308, - 1,0,0,0,312,309,1,0,0,0,312,310,1,0,0,0,313,63,1,0,0,0,314,316,5, - 78,0,0,315,317,5,92,0,0,316,315,1,0,0,0,316,317,1,0,0,0,317,318, - 1,0,0,0,318,319,5,83,0,0,319,320,3,78,39,0,320,321,5,84,0,0,321, - 65,1,0,0,0,322,324,5,79,0,0,323,325,5,92,0,0,324,323,1,0,0,0,324, - 325,1,0,0,0,325,326,1,0,0,0,326,327,5,83,0,0,327,328,3,78,39,0,328, - 329,5,84,0,0,329,67,1,0,0,0,330,332,5,80,0,0,331,333,5,92,0,0,332, - 331,1,0,0,0,332,333,1,0,0,0,333,334,1,0,0,0,334,335,5,83,0,0,335, - 336,3,78,39,0,336,337,5,84,0,0,337,69,1,0,0,0,338,340,5,75,0,0,339, - 341,5,92,0,0,340,339,1,0,0,0,340,341,1,0,0,0,341,348,1,0,0,0,342, - 343,5,83,0,0,343,344,3,78,39,0,344,345,5,89,0,0,345,346,3,78,39, - 0,346,347,5,84,0,0,347,349,1,0,0,0,348,342,1,0,0,0,348,349,1,0,0, - 0,349,71,1,0,0,0,350,352,5,76,0,0,351,353,5,92,0,0,352,351,1,0,0, - 0,352,353,1,0,0,0,353,354,1,0,0,0,354,355,5,83,0,0,355,356,3,78, - 39,0,356,357,5,84,0,0,357,73,1,0,0,0,358,360,5,77,0,0,359,361,5, - 92,0,0,360,359,1,0,0,0,360,361,1,0,0,0,361,362,1,0,0,0,362,363,5, - 83,0,0,363,364,3,78,39,0,364,365,5,84,0,0,365,75,1,0,0,0,366,373, - 3,64,32,0,367,373,3,66,33,0,368,373,3,68,34,0,369,373,3,70,35,0, - 370,373,3,72,36,0,371,373,3,74,37,0,372,366,1,0,0,0,372,367,1,0, - 0,0,372,368,1,0,0,0,372,369,1,0,0,0,372,370,1,0,0,0,372,371,1,0, - 0,0,373,77,1,0,0,0,374,375,5,14,0,0,375,79,1,0,0,0,376,377,7,1,0, - 0,377,81,1,0,0,0,378,379,3,84,42,0,379,380,5,91,0,0,380,381,3,86, - 43,0,381,83,1,0,0,0,382,383,7,2,0,0,383,85,1,0,0,0,384,385,7,3,0, - 0,385,87,1,0,0,0,386,391,3,82,41,0,387,388,5,89,0,0,388,390,3,82, - 41,0,389,387,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0, - 0,0,392,89,1,0,0,0,393,391,1,0,0,0,29,94,110,123,132,139,144,162, - 236,241,249,254,260,264,268,274,278,284,288,292,312,316,324,332, - 340,348,352,360,372,391 + 4, + 1, + 94, + 395, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 1, + 0, + 1, + 0, + 4, + 0, + 93, + 8, + 0, + 11, + 0, + 12, + 0, + 94, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 5, + 3, + 109, + 8, + 3, + 10, + 3, + 12, + 3, + 112, + 9, + 3, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 3, + 5, + 124, + 8, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 4, + 6, + 131, + 8, + 6, + 11, + 6, + 12, + 6, + 132, + 1, + 7, + 1, + 7, + 1, + 7, + 5, + 7, + 138, + 8, + 7, + 10, + 7, + 12, + 7, + 141, + 9, + 7, + 1, + 8, + 1, + 8, + 3, + 8, + 145, + 8, + 8, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 3, + 9, + 163, + 8, + 9, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 3, + 27, + 237, + 8, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 3, + 27, + 242, + 8, + 27, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 3, + 28, + 250, + 8, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 3, + 28, + 255, + 8, + 28, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 261, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 265, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 269, + 8, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 275, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 279, + 8, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 285, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 289, + 8, + 29, + 1, + 30, + 1, + 30, + 3, + 30, + 293, + 8, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 313, + 8, + 31, + 1, + 32, + 1, + 32, + 3, + 32, + 317, + 8, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 33, + 1, + 33, + 3, + 33, + 325, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 34, + 1, + 34, + 3, + 34, + 333, + 8, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 3, + 35, + 341, + 8, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 3, + 35, + 349, + 8, + 35, + 1, + 36, + 1, + 36, + 3, + 36, + 353, + 8, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 3, + 37, + 361, + 8, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 3, + 38, + 373, + 8, + 38, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 44, + 5, + 44, + 390, + 8, + 44, + 10, + 44, + 12, + 44, + 393, + 9, + 44, + 1, + 44, + 0, + 0, + 45, + 0, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32, + 34, + 36, + 38, + 40, + 42, + 44, + 46, + 48, + 50, + 52, + 54, + 56, + 58, + 60, + 62, + 64, + 66, + 68, + 70, + 72, + 74, + 76, + 78, + 80, + 82, + 84, + 86, + 88, + 0, + 4, + 1, + 0, + 14, + 16, + 1, + 0, + 5, + 6, + 2, + 0, + 7, + 8, + 82, + 82, + 1, + 0, + 9, + 13, + 413, + 0, + 90, + 1, + 0, + 0, + 0, + 2, + 98, + 1, + 0, + 0, + 0, + 4, + 101, + 1, + 0, + 0, + 0, + 6, + 104, + 1, + 0, + 0, + 0, + 8, + 113, + 1, + 0, + 0, + 0, + 10, + 115, + 1, + 0, + 0, + 0, + 12, + 128, + 1, + 0, + 0, + 0, + 14, + 134, + 1, + 0, + 0, + 0, + 16, + 144, + 1, + 0, + 0, + 0, + 18, + 162, + 1, + 0, + 0, + 0, + 20, + 164, + 1, + 0, + 0, + 0, + 22, + 166, + 1, + 0, + 0, + 0, + 24, + 170, + 1, + 0, + 0, + 0, + 26, + 174, + 1, + 0, + 0, + 0, + 28, + 178, + 1, + 0, + 0, + 0, + 30, + 182, + 1, + 0, + 0, + 0, + 32, + 186, + 1, + 0, + 0, + 0, + 34, + 190, + 1, + 0, + 0, + 0, + 36, + 194, + 1, + 0, + 0, + 0, + 38, + 198, + 1, + 0, + 0, + 0, + 40, + 202, + 1, + 0, + 0, + 0, + 42, + 206, + 1, + 0, + 0, + 0, + 44, + 210, + 1, + 0, + 0, + 0, + 46, + 214, + 1, + 0, + 0, + 0, + 48, + 218, + 1, + 0, + 0, + 0, + 50, + 222, + 1, + 0, + 0, + 0, + 52, + 226, + 1, + 0, + 0, + 0, + 54, + 241, + 1, + 0, + 0, + 0, + 56, + 254, + 1, + 0, + 0, + 0, + 58, + 288, + 1, + 0, + 0, + 0, + 60, + 292, + 1, + 0, + 0, + 0, + 62, + 312, + 1, + 0, + 0, + 0, + 64, + 314, + 1, + 0, + 0, + 0, + 66, + 322, + 1, + 0, + 0, + 0, + 68, + 330, + 1, + 0, + 0, + 0, + 70, + 338, + 1, + 0, + 0, + 0, + 72, + 350, + 1, + 0, + 0, + 0, + 74, + 358, + 1, + 0, + 0, + 0, + 76, + 372, + 1, + 0, + 0, + 0, + 78, + 374, + 1, + 0, + 0, + 0, + 80, + 376, + 1, + 0, + 0, + 0, + 82, + 378, + 1, + 0, + 0, + 0, + 84, + 382, + 1, + 0, + 0, + 0, + 86, + 384, + 1, + 0, + 0, + 0, + 88, + 386, + 1, + 0, + 0, + 0, + 90, + 92, + 3, + 2, + 1, + 0, + 91, + 93, + 3, + 12, + 6, + 0, + 92, + 91, + 1, + 0, + 0, + 0, + 93, + 94, + 1, + 0, + 0, + 0, + 94, + 92, + 1, + 0, + 0, + 0, + 94, + 95, + 1, + 0, + 0, + 0, + 95, + 96, + 1, + 0, + 0, + 0, + 96, + 97, + 5, + 0, + 0, + 1, + 97, + 1, + 1, + 0, + 0, + 0, + 98, + 99, + 3, + 4, + 2, + 0, + 99, + 100, + 3, + 6, + 3, + 0, + 100, + 3, + 1, + 0, + 0, + 0, + 101, + 102, + 5, + 1, + 0, + 0, + 102, + 103, + 5, + 2, + 0, + 0, + 103, + 5, + 1, + 0, + 0, + 0, + 104, + 105, + 5, + 3, + 0, + 0, + 105, + 110, + 5, + 33, + 0, + 0, + 106, + 107, + 5, + 89, + 0, + 0, + 107, + 109, + 5, + 33, + 0, + 0, + 108, + 106, + 1, + 0, + 0, + 0, + 109, + 112, + 1, + 0, + 0, + 0, + 110, + 108, + 1, + 0, + 0, + 0, + 110, + 111, + 1, + 0, + 0, + 0, + 111, + 7, + 1, + 0, + 0, + 0, + 112, + 110, + 1, + 0, + 0, + 0, + 113, + 114, + 5, + 4, + 0, + 0, + 114, + 9, + 1, + 0, + 0, + 0, + 115, + 116, + 5, + 82, + 0, + 0, + 116, + 117, + 5, + 85, + 0, + 0, + 117, + 118, + 3, + 14, + 7, + 0, + 118, + 123, + 5, + 86, + 0, + 0, + 119, + 120, + 5, + 87, + 0, + 0, + 120, + 121, + 3, + 88, + 44, + 0, + 121, + 122, + 5, + 88, + 0, + 0, + 122, + 124, + 1, + 0, + 0, + 0, + 123, + 119, + 1, + 0, + 0, + 0, + 123, + 124, + 1, + 0, + 0, + 0, + 124, + 125, + 1, + 0, + 0, + 0, + 125, + 126, + 5, + 90, + 0, + 0, + 126, + 127, + 3, + 16, + 8, + 0, + 127, + 11, + 1, + 0, + 0, + 0, + 128, + 130, + 3, + 8, + 4, + 0, + 129, + 131, + 3, + 10, + 5, + 0, + 130, + 129, + 1, + 0, + 0, + 0, + 131, + 132, + 1, + 0, + 0, + 0, + 132, + 130, + 1, + 0, + 0, + 0, + 132, + 133, + 1, + 0, + 0, + 0, + 133, + 13, + 1, + 0, + 0, + 0, + 134, + 139, + 3, + 18, + 9, + 0, + 135, + 136, + 5, + 89, + 0, + 0, + 136, + 138, + 3, + 18, + 9, + 0, + 137, + 135, + 1, + 0, + 0, + 0, + 138, + 141, + 1, + 0, + 0, + 0, + 139, + 137, + 1, + 0, + 0, + 0, + 139, + 140, + 1, + 0, + 0, + 0, + 140, + 15, + 1, + 0, + 0, + 0, + 141, + 139, + 1, + 0, + 0, + 0, + 142, + 145, + 3, + 18, + 9, + 0, + 143, + 145, + 3, + 80, + 40, + 0, + 144, + 142, + 1, + 0, + 0, + 0, + 144, + 143, + 1, + 0, + 0, + 0, + 145, + 17, + 1, + 0, + 0, + 0, + 146, + 163, + 3, + 22, + 11, + 0, + 147, + 163, + 3, + 24, + 12, + 0, + 148, + 163, + 3, + 26, + 13, + 0, + 149, + 163, + 3, + 28, + 14, + 0, + 150, + 163, + 3, + 30, + 15, + 0, + 151, + 163, + 3, + 32, + 16, + 0, + 152, + 163, + 3, + 34, + 17, + 0, + 153, + 163, + 3, + 38, + 19, + 0, + 154, + 163, + 3, + 40, + 20, + 0, + 155, + 163, + 3, + 36, + 18, + 0, + 156, + 163, + 3, + 42, + 21, + 0, + 157, + 163, + 3, + 44, + 22, + 0, + 158, + 163, + 3, + 46, + 23, + 0, + 159, + 163, + 3, + 48, + 24, + 0, + 160, + 163, + 3, + 50, + 25, + 0, + 161, + 163, + 3, + 52, + 26, + 0, + 162, + 146, + 1, + 0, + 0, + 0, + 162, + 147, + 1, + 0, + 0, + 0, + 162, + 148, + 1, + 0, + 0, + 0, + 162, + 149, + 1, + 0, + 0, + 0, + 162, + 150, + 1, + 0, + 0, + 0, + 162, + 151, + 1, + 0, + 0, + 0, + 162, + 152, + 1, + 0, + 0, + 0, + 162, + 153, + 1, + 0, + 0, + 0, + 162, + 154, + 1, + 0, + 0, + 0, + 162, + 155, + 1, + 0, + 0, + 0, + 162, + 156, + 1, + 0, + 0, + 0, + 162, + 157, + 1, + 0, + 0, + 0, + 162, + 158, + 1, + 0, + 0, + 0, + 162, + 159, + 1, + 0, + 0, + 0, + 162, + 160, + 1, + 0, + 0, + 0, + 162, + 161, + 1, + 0, + 0, + 0, + 163, + 19, + 1, + 0, + 0, + 0, + 164, + 165, + 7, + 0, + 0, + 0, + 165, + 21, + 1, + 0, + 0, + 0, + 166, + 167, + 5, + 32, + 0, + 0, + 167, + 168, + 5, + 81, + 0, + 0, + 168, + 169, + 3, + 60, + 30, + 0, + 169, + 23, + 1, + 0, + 0, + 0, + 170, + 171, + 5, + 14, + 0, + 0, + 171, + 172, + 5, + 81, + 0, + 0, + 172, + 173, + 5, + 41, + 0, + 0, + 173, + 25, + 1, + 0, + 0, + 0, + 174, + 175, + 5, + 14, + 0, + 0, + 175, + 176, + 5, + 81, + 0, + 0, + 176, + 177, + 5, + 42, + 0, + 0, + 177, + 27, + 1, + 0, + 0, + 0, + 178, + 179, + 5, + 14, + 0, + 0, + 179, + 180, + 5, + 81, + 0, + 0, + 180, + 181, + 5, + 43, + 0, + 0, + 181, + 29, + 1, + 0, + 0, + 0, + 182, + 183, + 5, + 14, + 0, + 0, + 183, + 184, + 5, + 81, + 0, + 0, + 184, + 185, + 5, + 44, + 0, + 0, + 185, + 31, + 1, + 0, + 0, + 0, + 186, + 187, + 3, + 20, + 10, + 0, + 187, + 188, + 5, + 81, + 0, + 0, + 188, + 189, + 5, + 45, + 0, + 0, + 189, + 33, + 1, + 0, + 0, + 0, + 190, + 191, + 3, + 20, + 10, + 0, + 191, + 192, + 5, + 81, + 0, + 0, + 192, + 193, + 5, + 46, + 0, + 0, + 193, + 35, + 1, + 0, + 0, + 0, + 194, + 195, + 3, + 20, + 10, + 0, + 195, + 196, + 5, + 81, + 0, + 0, + 196, + 197, + 3, + 70, + 35, + 0, + 197, + 37, + 1, + 0, + 0, + 0, + 198, + 199, + 5, + 17, + 0, + 0, + 199, + 200, + 5, + 81, + 0, + 0, + 200, + 201, + 5, + 68, + 0, + 0, + 201, + 39, + 1, + 0, + 0, + 0, + 202, + 203, + 5, + 33, + 0, + 0, + 203, + 204, + 5, + 81, + 0, + 0, + 204, + 205, + 5, + 69, + 0, + 0, + 205, + 41, + 1, + 0, + 0, + 0, + 206, + 207, + 5, + 21, + 0, + 0, + 207, + 208, + 5, + 81, + 0, + 0, + 208, + 209, + 5, + 51, + 0, + 0, + 209, + 43, + 1, + 0, + 0, + 0, + 210, + 211, + 5, + 20, + 0, + 0, + 211, + 212, + 5, + 81, + 0, + 0, + 212, + 213, + 5, + 52, + 0, + 0, + 213, + 45, + 1, + 0, + 0, + 0, + 214, + 215, + 5, + 19, + 0, + 0, + 215, + 216, + 5, + 81, + 0, + 0, + 216, + 217, + 5, + 71, + 0, + 0, + 217, + 47, + 1, + 0, + 0, + 0, + 218, + 219, + 5, + 18, + 0, + 0, + 219, + 220, + 5, + 81, + 0, + 0, + 220, + 221, + 5, + 72, + 0, + 0, + 221, + 49, + 1, + 0, + 0, + 0, + 222, + 223, + 5, + 30, + 0, + 0, + 223, + 224, + 5, + 81, + 0, + 0, + 224, + 225, + 5, + 73, + 0, + 0, + 225, + 51, + 1, + 0, + 0, + 0, + 226, + 227, + 5, + 31, + 0, + 0, + 227, + 228, + 5, + 81, + 0, + 0, + 228, + 229, + 5, + 74, + 0, + 0, + 229, + 53, + 1, + 0, + 0, + 0, + 230, + 231, + 5, + 22, + 0, + 0, + 231, + 232, + 5, + 14, + 0, + 0, + 232, + 233, + 5, + 24, + 0, + 0, + 233, + 236, + 1, + 0, + 0, + 0, + 234, + 235, + 5, + 14, + 0, + 0, + 235, + 237, + 5, + 25, + 0, + 0, + 236, + 234, + 1, + 0, + 0, + 0, + 236, + 237, + 1, + 0, + 0, + 0, + 237, + 242, + 1, + 0, + 0, + 0, + 238, + 239, + 5, + 22, + 0, + 0, + 239, + 240, + 5, + 14, + 0, + 0, + 240, + 242, + 5, + 25, + 0, + 0, + 241, + 230, + 1, + 0, + 0, + 0, + 241, + 238, + 1, + 0, + 0, + 0, + 242, + 55, + 1, + 0, + 0, + 0, + 243, + 244, + 5, + 22, + 0, + 0, + 244, + 245, + 5, + 14, + 0, + 0, + 245, + 246, + 5, + 26, + 0, + 0, + 246, + 249, + 1, + 0, + 0, + 0, + 247, + 248, + 5, + 23, + 0, + 0, + 248, + 250, + 3, + 58, + 29, + 0, + 249, + 247, + 1, + 0, + 0, + 0, + 249, + 250, + 1, + 0, + 0, + 0, + 250, + 255, + 1, + 0, + 0, + 0, + 251, + 252, + 5, + 22, + 0, + 0, + 252, + 253, + 5, + 23, + 0, + 0, + 253, + 255, + 3, + 58, + 29, + 0, + 254, + 243, + 1, + 0, + 0, + 0, + 254, + 251, + 1, + 0, + 0, + 0, + 255, + 57, + 1, + 0, + 0, + 0, + 256, + 257, + 5, + 14, + 0, + 0, + 257, + 260, + 5, + 27, + 0, + 0, + 258, + 259, + 5, + 14, + 0, + 0, + 259, + 261, + 5, + 25, + 0, + 0, + 260, + 258, + 1, + 0, + 0, + 0, + 260, + 261, + 1, + 0, + 0, + 0, + 261, + 264, + 1, + 0, + 0, + 0, + 262, + 263, + 5, + 14, + 0, + 0, + 263, + 265, + 5, + 28, + 0, + 0, + 264, + 262, + 1, + 0, + 0, + 0, + 264, + 265, + 1, + 0, + 0, + 0, + 265, + 268, + 1, + 0, + 0, + 0, + 266, + 267, + 5, + 14, + 0, + 0, + 267, + 269, + 5, + 29, + 0, + 0, + 268, + 266, + 1, + 0, + 0, + 0, + 268, + 269, + 1, + 0, + 0, + 0, + 269, + 289, + 1, + 0, + 0, + 0, + 270, + 271, + 5, + 14, + 0, + 0, + 271, + 274, + 5, + 25, + 0, + 0, + 272, + 273, + 5, + 14, + 0, + 0, + 273, + 275, + 5, + 28, + 0, + 0, + 274, + 272, + 1, + 0, + 0, + 0, + 274, + 275, + 1, + 0, + 0, + 0, + 275, + 278, + 1, + 0, + 0, + 0, + 276, + 277, + 5, + 14, + 0, + 0, + 277, + 279, + 5, + 29, + 0, + 0, + 278, + 276, + 1, + 0, + 0, + 0, + 278, + 279, + 1, + 0, + 0, + 0, + 279, + 289, + 1, + 0, + 0, + 0, + 280, + 281, + 5, + 14, + 0, + 0, + 281, + 284, + 5, + 28, + 0, + 0, + 282, + 283, + 5, + 14, + 0, + 0, + 283, + 285, + 5, + 29, + 0, + 0, + 284, + 282, + 1, + 0, + 0, + 0, + 284, + 285, + 1, + 0, + 0, + 0, + 285, + 289, + 1, + 0, + 0, + 0, + 286, + 287, + 5, + 14, + 0, + 0, + 287, + 289, + 5, + 29, + 0, + 0, + 288, + 256, + 1, + 0, + 0, + 0, + 288, + 270, + 1, + 0, + 0, + 0, + 288, + 280, + 1, + 0, + 0, + 0, + 288, + 286, + 1, + 0, + 0, + 0, + 289, + 59, + 1, + 0, + 0, + 0, + 290, + 293, + 3, + 62, + 31, + 0, + 291, + 293, + 3, + 76, + 38, + 0, + 292, + 290, + 1, + 0, + 0, + 0, + 292, + 291, + 1, + 0, + 0, + 0, + 293, + 61, + 1, + 0, + 0, + 0, + 294, + 313, + 5, + 68, + 0, + 0, + 295, + 313, + 5, + 41, + 0, + 0, + 296, + 313, + 5, + 42, + 0, + 0, + 297, + 313, + 5, + 43, + 0, + 0, + 298, + 313, + 5, + 44, + 0, + 0, + 299, + 313, + 5, + 45, + 0, + 0, + 300, + 313, + 5, + 46, + 0, + 0, + 301, + 313, + 5, + 69, + 0, + 0, + 302, + 313, + 5, + 48, + 0, + 0, + 303, + 313, + 5, + 71, + 0, + 0, + 304, + 313, + 5, + 72, + 0, + 0, + 305, + 313, + 5, + 51, + 0, + 0, + 306, + 313, + 5, + 52, + 0, + 0, + 307, + 313, + 5, + 74, + 0, + 0, + 308, + 313, + 5, + 73, + 0, + 0, + 309, + 313, + 5, + 55, + 0, + 0, + 310, + 311, + 5, + 67, + 0, + 0, + 311, + 313, + 5, + 82, + 0, + 0, + 312, + 294, + 1, + 0, + 0, + 0, + 312, + 295, + 1, + 0, + 0, + 0, + 312, + 296, + 1, + 0, + 0, + 0, + 312, + 297, + 1, + 0, + 0, + 0, + 312, + 298, + 1, + 0, + 0, + 0, + 312, + 299, + 1, + 0, + 0, + 0, + 312, + 300, + 1, + 0, + 0, + 0, + 312, + 301, + 1, + 0, + 0, + 0, + 312, + 302, + 1, + 0, + 0, + 0, + 312, + 303, + 1, + 0, + 0, + 0, + 312, + 304, + 1, + 0, + 0, + 0, + 312, + 305, + 1, + 0, + 0, + 0, + 312, + 306, + 1, + 0, + 0, + 0, + 312, + 307, + 1, + 0, + 0, + 0, + 312, + 308, + 1, + 0, + 0, + 0, + 312, + 309, + 1, + 0, + 0, + 0, + 312, + 310, + 1, + 0, + 0, + 0, + 313, + 63, + 1, + 0, + 0, + 0, + 314, + 316, + 5, + 78, + 0, + 0, + 315, + 317, + 5, + 92, + 0, + 0, + 316, + 315, + 1, + 0, + 0, + 0, + 316, + 317, + 1, + 0, + 0, + 0, + 317, + 318, + 1, + 0, + 0, + 0, + 318, + 319, + 5, + 83, + 0, + 0, + 319, + 320, + 3, + 78, + 39, + 0, + 320, + 321, + 5, + 84, + 0, + 0, + 321, + 65, + 1, + 0, + 0, + 0, + 322, + 324, + 5, + 79, + 0, + 0, + 323, + 325, + 5, + 92, + 0, + 0, + 324, + 323, + 1, + 0, + 0, + 0, + 324, + 325, + 1, + 0, + 0, + 0, + 325, + 326, + 1, + 0, + 0, + 0, + 326, + 327, + 5, + 83, + 0, + 0, + 327, + 328, + 3, + 78, + 39, + 0, + 328, + 329, + 5, + 84, + 0, + 0, + 329, + 67, + 1, + 0, + 0, + 0, + 330, + 332, + 5, + 80, + 0, + 0, + 331, + 333, + 5, + 92, + 0, + 0, + 332, + 331, + 1, + 0, + 0, + 0, + 332, + 333, + 1, + 0, + 0, + 0, + 333, + 334, + 1, + 0, + 0, + 0, + 334, + 335, + 5, + 83, + 0, + 0, + 335, + 336, + 3, + 78, + 39, + 0, + 336, + 337, + 5, + 84, + 0, + 0, + 337, + 69, + 1, + 0, + 0, + 0, + 338, + 340, + 5, + 75, + 0, + 0, + 339, + 341, + 5, + 92, + 0, + 0, + 340, + 339, + 1, + 0, + 0, + 0, + 340, + 341, + 1, + 0, + 0, + 0, + 341, + 348, + 1, + 0, + 0, + 0, + 342, + 343, + 5, + 83, + 0, + 0, + 343, + 344, + 3, + 78, + 39, + 0, + 344, + 345, + 5, + 89, + 0, + 0, + 345, + 346, + 3, + 78, + 39, + 0, + 346, + 347, + 5, + 84, + 0, + 0, + 347, + 349, + 1, + 0, + 0, + 0, + 348, + 342, + 1, + 0, + 0, + 0, + 348, + 349, + 1, + 0, + 0, + 0, + 349, + 71, + 1, + 0, + 0, + 0, + 350, + 352, + 5, + 76, + 0, + 0, + 351, + 353, + 5, + 92, + 0, + 0, + 352, + 351, + 1, + 0, + 0, + 0, + 352, + 353, + 1, + 0, + 0, + 0, + 353, + 354, + 1, + 0, + 0, + 0, + 354, + 355, + 5, + 83, + 0, + 0, + 355, + 356, + 3, + 78, + 39, + 0, + 356, + 357, + 5, + 84, + 0, + 0, + 357, + 73, + 1, + 0, + 0, + 0, + 358, + 360, + 5, + 77, + 0, + 0, + 359, + 361, + 5, + 92, + 0, + 0, + 360, + 359, + 1, + 0, + 0, + 0, + 360, + 361, + 1, + 0, + 0, + 0, + 361, + 362, + 1, + 0, + 0, + 0, + 362, + 363, + 5, + 83, + 0, + 0, + 363, + 364, + 3, + 78, + 39, + 0, + 364, + 365, + 5, + 84, + 0, + 0, + 365, + 75, + 1, + 0, + 0, + 0, + 366, + 373, + 3, + 64, + 32, + 0, + 367, + 373, + 3, + 66, + 33, + 0, + 368, + 373, + 3, + 68, + 34, + 0, + 369, + 373, + 3, + 70, + 35, + 0, + 370, + 373, + 3, + 72, + 36, + 0, + 371, + 373, + 3, + 74, + 37, + 0, + 372, + 366, + 1, + 0, + 0, + 0, + 372, + 367, + 1, + 0, + 0, + 0, + 372, + 368, + 1, + 0, + 0, + 0, + 372, + 369, + 1, + 0, + 0, + 0, + 372, + 370, + 1, + 0, + 0, + 0, + 372, + 371, + 1, + 0, + 0, + 0, + 373, + 77, + 1, + 0, + 0, + 0, + 374, + 375, + 5, + 14, + 0, + 0, + 375, + 79, + 1, + 0, + 0, + 0, + 376, + 377, + 7, + 1, + 0, + 0, + 377, + 81, + 1, + 0, + 0, + 0, + 378, + 379, + 3, + 84, + 42, + 0, + 379, + 380, + 5, + 91, + 0, + 0, + 380, + 381, + 3, + 86, + 43, + 0, + 381, + 83, + 1, + 0, + 0, + 0, + 382, + 383, + 7, + 2, + 0, + 0, + 383, + 85, + 1, + 0, + 0, + 0, + 384, + 385, + 7, + 3, + 0, + 0, + 385, + 87, + 1, + 0, + 0, + 0, + 386, + 391, + 3, + 82, + 41, + 0, + 387, + 388, + 5, + 89, + 0, + 0, + 388, + 390, + 3, + 82, + 41, + 0, + 389, + 387, + 1, + 0, + 0, + 0, + 390, + 393, + 1, + 0, + 0, + 0, + 391, + 389, + 1, + 0, + 0, + 0, + 391, + 392, + 1, + 0, + 0, + 0, + 392, + 89, + 1, + 0, + 0, + 0, + 393, + 391, + 1, + 0, + 0, + 0, + 29, + 94, + 110, + 123, + 132, + 139, + 144, + 162, + 236, + 241, + 249, + 254, + 260, + 264, + 268, + 274, + 278, + 284, + 288, + 292, + 312, + 316, + 324, + 332, + 340, + 348, + 352, + 360, + 372, + 391, ] -class TestFileParser ( Parser ): + +class TestFileParser(Parser): grammarFileName = "TestFileParser.g4" atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] sharedContextCache = PredictionContextCache() - literalNames = [ "", "'### SUBSTRAIT_SCALAR_TEST:'", "", - "'### SUBSTRAIT_INCLUDE:'", "", "''", - "''", "'overlfow'", "'rounding'", "'ERROR'", - "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", - "", "", "", "", - "", "", "", "", - "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", - "", "", "'null'", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "'::'", "", "'<'", - "'>'", "'('", "')'", "'['", "']'", "','", "'='", "':'", - "'?'", "'#'", "'.'" ] - - symbolicNames = [ "", "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", - "SUBSTRAIT_INCLUDE", "DESCRIPTION_LINE", "ERROR_RESULT", - "UNDEFINED_RESULT", "OVERFLOW", "ROUNDING", "ERROR", - "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", - "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", - "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", - "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", - "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", - "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", - "INTERVAL_DAY_LITERAL", "NULL_LITERAL", "STRING_LITERAL", - "LineComment", "BlockComment", "Whitespace", "If", - "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", - "FP32", "FP64", "String", "Binary", "Timestamp", "TimestampTZ", - "Date", "Time", "IntervalYear", "IntervalDay", "UUID", - "Decimal", "PrecisionTimestamp", "PrecisionTimestampTZ", - "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", - "List", "Map", "ANY", "UserDefined", "Bool", "Str", - "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", - "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", - "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", - "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", - "EQ", "COLON", "QMARK", "HASH", "DOT" ] + literalNames = [ + "", + "'### SUBSTRAIT_SCALAR_TEST:'", + "", + "'### SUBSTRAIT_INCLUDE:'", + "", + "''", + "''", + "'overlfow'", + "'rounding'", + "'ERROR'", + "'SATURATE'", + "'SILENT'", + "'TIE_TO_EVEN'", + "'NAN'", + "", + "", + "", + "", + "", + "", + "", + "", + "'P'", + "'T'", + "'Y'", + "'M'", + "'D'", + "'H'", + "'S'", + "'F'", + "", + "", + "'null'", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "'::'", + "", + "'<'", + "'>'", + "'('", + "')'", + "'['", + "']'", + "','", + "'='", + "':'", + "'?'", + "'#'", + "'.'", + ] + + symbolicNames = [ + "", + "SUBSTRAIT_SCALAR_TEST", + "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", + "ERROR_RESULT", + "UNDEFINED_RESULT", + "OVERFLOW", + "ROUNDING", + "ERROR", + "SATURATE", + "SILENT", + "TIE_TO_EVEN", + "NAN", + "INTEGER_LITERAL", + "DECIMAL_LITERAL", + "FLOAT_LITERAL", + "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", + "TIMESTAMP_LITERAL", + "TIME_LITERAL", + "DATE_LITERAL", + "PERIOD_PREFIX", + "TIME_PREFIX", + "YEAR_SUFFIX", + "M_SUFFIX", + "DAY_SUFFIX", + "HOUR_SUFFIX", + "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", + "NULL_LITERAL", + "STRING_LITERAL", + "LineComment", + "BlockComment", + "Whitespace", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "TimestampTZ", + "Date", + "Time", + "IntervalYear", + "IntervalDay", + "UUID", + "Decimal", + "PrecisionTimestamp", + "PrecisionTimestampTZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] RULE_doc = 0 RULE_header = 1 @@ -254,183 +3672,215 @@ class TestFileParser ( Parser ): RULE_option_value = 43 RULE_func_options = 44 - ruleNames = [ "doc", "header", "version", "include", "testGroupDescription", - "testCase", "testGroup", "arguments", "result", "argument", - "numericLiteral", "nullArg", "i8Arg", "i16Arg", "i32Arg", - "i64Arg", "fp32Arg", "fp64Arg", "decimalArg", "booleanArg", - "stringArg", "dateArg", "timeArg", "timestampArg", "timestampTzArg", - "intervalYearArg", "intervalDayArg", "intervalYearLiteral", - "intervalDayLiteral", "timeInterval", "datatype", "scalarType", - "fixedCharType", "varCharType", "fixedBinaryType", "decimalType", - "precisionTimestampType", "precisionTimestampTZType", - "parameterizedType", "numericParameter", "substraitError", - "func_option", "option_name", "option_value", "func_options" ] + ruleNames = [ + "doc", + "header", + "version", + "include", + "testGroupDescription", + "testCase", + "testGroup", + "arguments", + "result", + "argument", + "numericLiteral", + "nullArg", + "i8Arg", + "i16Arg", + "i32Arg", + "i64Arg", + "fp32Arg", + "fp64Arg", + "decimalArg", + "booleanArg", + "stringArg", + "dateArg", + "timeArg", + "timestampArg", + "timestampTzArg", + "intervalYearArg", + "intervalDayArg", + "intervalYearLiteral", + "intervalDayLiteral", + "timeInterval", + "datatype", + "scalarType", + "fixedCharType", + "varCharType", + "fixedBinaryType", + "decimalType", + "precisionTimestampType", + "precisionTimestampTZType", + "parameterizedType", + "numericParameter", + "substraitError", + "func_option", + "option_name", + "option_value", + "func_options", + ] EOF = Token.EOF - SUBSTRAIT_SCALAR_TEST=1 - FORMAT_VERSION=2 - SUBSTRAIT_INCLUDE=3 - DESCRIPTION_LINE=4 - ERROR_RESULT=5 - UNDEFINED_RESULT=6 - OVERFLOW=7 - ROUNDING=8 - ERROR=9 - SATURATE=10 - SILENT=11 - TIE_TO_EVEN=12 - NAN=13 - INTEGER_LITERAL=14 - DECIMAL_LITERAL=15 - FLOAT_LITERAL=16 - BOOLEAN_LITERAL=17 - TIMESTAMP_TZ_LITERAL=18 - TIMESTAMP_LITERAL=19 - TIME_LITERAL=20 - DATE_LITERAL=21 - PERIOD_PREFIX=22 - TIME_PREFIX=23 - YEAR_SUFFIX=24 - M_SUFFIX=25 - DAY_SUFFIX=26 - HOUR_SUFFIX=27 - SECOND_SUFFIX=28 - FRACTIONAL_SECOND_SUFFIX=29 - INTERVAL_YEAR_LITERAL=30 - INTERVAL_DAY_LITERAL=31 - NULL_LITERAL=32 - STRING_LITERAL=33 - LineComment=34 - BlockComment=35 - Whitespace=36 - If=37 - Then=38 - Else=39 - Boolean=40 - I8=41 - I16=42 - I32=43 - I64=44 - FP32=45 - FP64=46 - String=47 - Binary=48 - Timestamp=49 - TimestampTZ=50 - Date=51 - Time=52 - IntervalYear=53 - IntervalDay=54 - UUID=55 - Decimal=56 - PrecisionTimestamp=57 - PrecisionTimestampTZ=58 - FixedChar=59 - VarChar=60 - FixedBinary=61 - Struct=62 - NStruct=63 - List=64 - Map=65 - ANY=66 - UserDefined=67 - Bool=68 - Str=69 - VBin=70 - Ts=71 - TsTZ=72 - IYear=73 - IDay=74 - Dec=75 - PTs=76 - PTsTZ=77 - FChar=78 - VChar=79 - FBin=80 - DOUBLE_COLON=81 - IDENTIFIER=82 - O_ANGLE_BRACKET=83 - C_ANGLE_BRACKET=84 - OPAREN=85 - CPAREN=86 - OBRACKET=87 - CBRACKET=88 - COMMA=89 - EQ=90 - COLON=91 - QMARK=92 - HASH=93 - DOT=94 - - def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + SUBSTRAIT_SCALAR_TEST = 1 + FORMAT_VERSION = 2 + SUBSTRAIT_INCLUDE = 3 + DESCRIPTION_LINE = 4 + ERROR_RESULT = 5 + UNDEFINED_RESULT = 6 + OVERFLOW = 7 + ROUNDING = 8 + ERROR = 9 + SATURATE = 10 + SILENT = 11 + TIE_TO_EVEN = 12 + NAN = 13 + INTEGER_LITERAL = 14 + DECIMAL_LITERAL = 15 + FLOAT_LITERAL = 16 + BOOLEAN_LITERAL = 17 + TIMESTAMP_TZ_LITERAL = 18 + TIMESTAMP_LITERAL = 19 + TIME_LITERAL = 20 + DATE_LITERAL = 21 + PERIOD_PREFIX = 22 + TIME_PREFIX = 23 + YEAR_SUFFIX = 24 + M_SUFFIX = 25 + DAY_SUFFIX = 26 + HOUR_SUFFIX = 27 + SECOND_SUFFIX = 28 + FRACTIONAL_SECOND_SUFFIX = 29 + INTERVAL_YEAR_LITERAL = 30 + INTERVAL_DAY_LITERAL = 31 + NULL_LITERAL = 32 + STRING_LITERAL = 33 + LineComment = 34 + BlockComment = 35 + Whitespace = 36 + If = 37 + Then = 38 + Else = 39 + Boolean = 40 + I8 = 41 + I16 = 42 + I32 = 43 + I64 = 44 + FP32 = 45 + FP64 = 46 + String = 47 + Binary = 48 + Timestamp = 49 + TimestampTZ = 50 + Date = 51 + Time = 52 + IntervalYear = 53 + IntervalDay = 54 + UUID = 55 + Decimal = 56 + PrecisionTimestamp = 57 + PrecisionTimestampTZ = 58 + FixedChar = 59 + VarChar = 60 + FixedBinary = 61 + Struct = 62 + NStruct = 63 + List = 64 + Map = 65 + ANY = 66 + UserDefined = 67 + Bool = 68 + Str = 69 + VBin = 70 + Ts = 71 + TsTZ = 72 + IYear = 73 + IDay = 74 + Dec = 75 + PTs = 76 + PTsTZ = 77 + FChar = 78 + VChar = 79 + FBin = 80 + DOUBLE_COLON = 81 + IDENTIFIER = 82 + O_ANGLE_BRACKET = 83 + C_ANGLE_BRACKET = 84 + OPAREN = 85 + CPAREN = 86 + OBRACKET = 87 + CBRACKET = 88 + COMMA = 89 + EQ = 90 + COLON = 91 + QMARK = 92 + HASH = 93 + DOT = 94 + + def __init__(self, input: TokenStream, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") - self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._interp = ParserATNSimulator( + self, self.atn, self.decisionsToDFA, self.sharedContextCache + ) self._predicates = None - - - class DocContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def header(self): - return self.getTypedRuleContext(TestFileParser.HeaderContext,0) - + return self.getTypedRuleContext(TestFileParser.HeaderContext, 0) def EOF(self): return self.getToken(TestFileParser.EOF, 0) - def testGroup(self, i:int=None): + def testGroup(self, i: int = None): if i is None: return self.getTypedRuleContexts(TestFileParser.TestGroupContext) else: - return self.getTypedRuleContext(TestFileParser.TestGroupContext,i) - + return self.getTypedRuleContext(TestFileParser.TestGroupContext, i) def getRuleIndex(self): return TestFileParser.RULE_doc - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDoc" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDoc"): listener.enterDoc(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDoc" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDoc"): listener.exitDoc(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDoc" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDoc"): return visitor.visitDoc(self) else: return visitor.visitChildren(self) - - - def doc(self): localctx = TestFileParser.DocContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_doc) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 90 self.header() - self.state = 92 + self.state = 92 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 91 self.testGroup() - self.state = 94 + self.state = 94 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==4): + if not (_la == 4): break self.state = 96 @@ -443,42 +3893,38 @@ def doc(self): self.exitRule() return localctx - class HeaderContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def version(self): - return self.getTypedRuleContext(TestFileParser.VersionContext,0) - + return self.getTypedRuleContext(TestFileParser.VersionContext, 0) def include(self): - return self.getTypedRuleContext(TestFileParser.IncludeContext,0) - + return self.getTypedRuleContext(TestFileParser.IncludeContext, 0) def getRuleIndex(self): return TestFileParser.RULE_header - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHeader" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHeader"): listener.enterHeader(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHeader" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHeader"): listener.exitHeader(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHeader" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHeader"): return visitor.visitHeader(self) else: return visitor.visitChildren(self) - - - def header(self): localctx = TestFileParser.HeaderContext(self, self._ctx, self.state) @@ -497,11 +3943,12 @@ def header(self): self.exitRule() return localctx - class VersionContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -514,23 +3961,20 @@ def FORMAT_VERSION(self): def getRuleIndex(self): return TestFileParser.RULE_version - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVersion" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVersion"): listener.enterVersion(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVersion" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVersion"): listener.exitVersion(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVersion" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVersion"): return visitor.visitVersion(self) else: return visitor.visitChildren(self) - - - def version(self): localctx = TestFileParser.VersionContext(self, self._ctx, self.state) @@ -549,24 +3993,25 @@ def version(self): self.exitRule() return localctx - class IncludeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def SUBSTRAIT_INCLUDE(self): return self.getToken(TestFileParser.SUBSTRAIT_INCLUDE, 0) - def STRING_LITERAL(self, i:int=None): + def STRING_LITERAL(self, i: int = None): if i is None: return self.getTokens(TestFileParser.STRING_LITERAL) else: return self.getToken(TestFileParser.STRING_LITERAL, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(TestFileParser.COMMA) else: @@ -575,28 +4020,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return TestFileParser.RULE_include - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInclude" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInclude"): listener.enterInclude(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInclude" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInclude"): listener.exitInclude(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInclude" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInclude"): return visitor.visitInclude(self) else: return visitor.visitChildren(self) - - - def include(self): localctx = TestFileParser.IncludeContext(self, self._ctx, self.state) self.enterRule(localctx, 6, self.RULE_include) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 104 @@ -606,7 +4048,7 @@ def include(self): self.state = 110 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==89: + while _la == 89: self.state = 106 self.match(TestFileParser.COMMA) self.state = 107 @@ -623,11 +4065,12 @@ def include(self): self.exitRule() return localctx - class TestGroupDescriptionContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -637,26 +4080,25 @@ def DESCRIPTION_LINE(self): def getRuleIndex(self): return TestFileParser.RULE_testGroupDescription - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTestGroupDescription" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestGroupDescription"): listener.enterTestGroupDescription(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTestGroupDescription" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestGroupDescription"): listener.exitTestGroupDescription(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTestGroupDescription" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestGroupDescription"): return visitor.visitTestGroupDescription(self) else: return visitor.visitChildren(self) - - - def testGroupDescription(self): - localctx = TestFileParser.TestGroupDescriptionContext(self, self._ctx, self.state) + localctx = TestFileParser.TestGroupDescriptionContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 8, self.RULE_testGroupDescription) try: self.enterOuterAlt(localctx, 1) @@ -670,21 +4112,21 @@ def testGroupDescription(self): self.exitRule() return localctx - class TestCaseContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.functionName = None # Token + self.functionName = None # Token def OPAREN(self): return self.getToken(TestFileParser.OPAREN, 0) def arguments(self): - return self.getTypedRuleContext(TestFileParser.ArgumentsContext,0) - + return self.getTypedRuleContext(TestFileParser.ArgumentsContext, 0) def CPAREN(self): return self.getToken(TestFileParser.CPAREN, 0) @@ -693,8 +4135,7 @@ def EQ(self): return self.getToken(TestFileParser.EQ, 0) def result(self): - return self.getTypedRuleContext(TestFileParser.ResultContext,0) - + return self.getTypedRuleContext(TestFileParser.ResultContext, 0) def IDENTIFIER(self): return self.getToken(TestFileParser.IDENTIFIER, 0) @@ -703,8 +4144,7 @@ def OBRACKET(self): return self.getToken(TestFileParser.OBRACKET, 0) def func_options(self): - return self.getTypedRuleContext(TestFileParser.Func_optionsContext,0) - + return self.getTypedRuleContext(TestFileParser.Func_optionsContext, 0) def CBRACKET(self): return self.getToken(TestFileParser.CBRACKET, 0) @@ -712,28 +4152,25 @@ def CBRACKET(self): def getRuleIndex(self): return TestFileParser.RULE_testCase - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTestCase" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestCase"): listener.enterTestCase(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTestCase" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestCase"): listener.exitTestCase(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTestCase" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestCase"): return visitor.visitTestCase(self) else: return visitor.visitChildren(self) - - - def testCase(self): localctx = TestFileParser.TestCaseContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_testCase) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 115 @@ -747,7 +4184,7 @@ def testCase(self): self.state = 123 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==87: + if _la == 87: self.state = 119 self.match(TestFileParser.OBRACKET) self.state = 120 @@ -755,7 +4192,6 @@ def testCase(self): self.state = 121 self.match(TestFileParser.CBRACKET) - self.state = 125 self.match(TestFileParser.EQ) self.state = 126 @@ -768,64 +4204,62 @@ def testCase(self): self.exitRule() return localctx - class TestGroupContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def testGroupDescription(self): - return self.getTypedRuleContext(TestFileParser.TestGroupDescriptionContext,0) - + return self.getTypedRuleContext( + TestFileParser.TestGroupDescriptionContext, 0 + ) - def testCase(self, i:int=None): + def testCase(self, i: int = None): if i is None: return self.getTypedRuleContexts(TestFileParser.TestCaseContext) else: - return self.getTypedRuleContext(TestFileParser.TestCaseContext,i) - + return self.getTypedRuleContext(TestFileParser.TestCaseContext, i) def getRuleIndex(self): return TestFileParser.RULE_testGroup - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTestGroup" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestGroup"): listener.enterTestGroup(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTestGroup" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestGroup"): listener.exitTestGroup(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTestGroup" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestGroup"): return visitor.visitTestGroup(self) else: return visitor.visitChildren(self) - - - def testGroup(self): localctx = TestFileParser.TestGroupContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_testGroup) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 128 self.testGroupDescription() - self.state = 130 + self.state = 130 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 129 self.testCase() - self.state = 132 + self.state = 132 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==82): + if not (_la == 82): break except RecognitionException as re: @@ -836,22 +4270,22 @@ def testGroup(self): self.exitRule() return localctx - class ArgumentsContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def argument(self, i:int=None): + def argument(self, i: int = None): if i is None: return self.getTypedRuleContexts(TestFileParser.ArgumentContext) else: - return self.getTypedRuleContext(TestFileParser.ArgumentContext,i) + return self.getTypedRuleContext(TestFileParser.ArgumentContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(TestFileParser.COMMA) else: @@ -860,28 +4294,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return TestFileParser.RULE_arguments - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArguments" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArguments"): listener.enterArguments(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArguments" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArguments"): listener.exitArguments(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArguments" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArguments"): return visitor.visitArguments(self) else: return visitor.visitChildren(self) - - - def arguments(self): localctx = TestFileParser.ArgumentsContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_arguments) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 134 @@ -889,7 +4320,7 @@ def arguments(self): self.state = 139 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==89: + while _la == 89: self.state = 135 self.match(TestFileParser.COMMA) self.state = 136 @@ -906,42 +4337,38 @@ def arguments(self): self.exitRule() return localctx - class ResultContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def argument(self): - return self.getTypedRuleContext(TestFileParser.ArgumentContext,0) - + return self.getTypedRuleContext(TestFileParser.ArgumentContext, 0) def substraitError(self): - return self.getTypedRuleContext(TestFileParser.SubstraitErrorContext,0) - + return self.getTypedRuleContext(TestFileParser.SubstraitErrorContext, 0) def getRuleIndex(self): return TestFileParser.RULE_result - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterResult" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterResult"): listener.enterResult(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitResult" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitResult"): listener.exitResult(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitResult" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitResult"): return visitor.visitResult(self) else: return visitor.visitChildren(self) - - - def result(self): localctx = TestFileParser.ResultContext(self, self._ctx, self.state) @@ -971,98 +4398,80 @@ def result(self): self.exitRule() return localctx - class ArgumentContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def nullArg(self): - return self.getTypedRuleContext(TestFileParser.NullArgContext,0) - + return self.getTypedRuleContext(TestFileParser.NullArgContext, 0) def i8Arg(self): - return self.getTypedRuleContext(TestFileParser.I8ArgContext,0) - + return self.getTypedRuleContext(TestFileParser.I8ArgContext, 0) def i16Arg(self): - return self.getTypedRuleContext(TestFileParser.I16ArgContext,0) - + return self.getTypedRuleContext(TestFileParser.I16ArgContext, 0) def i32Arg(self): - return self.getTypedRuleContext(TestFileParser.I32ArgContext,0) - + return self.getTypedRuleContext(TestFileParser.I32ArgContext, 0) def i64Arg(self): - return self.getTypedRuleContext(TestFileParser.I64ArgContext,0) - + return self.getTypedRuleContext(TestFileParser.I64ArgContext, 0) def fp32Arg(self): - return self.getTypedRuleContext(TestFileParser.Fp32ArgContext,0) - + return self.getTypedRuleContext(TestFileParser.Fp32ArgContext, 0) def fp64Arg(self): - return self.getTypedRuleContext(TestFileParser.Fp64ArgContext,0) - + return self.getTypedRuleContext(TestFileParser.Fp64ArgContext, 0) def booleanArg(self): - return self.getTypedRuleContext(TestFileParser.BooleanArgContext,0) - + return self.getTypedRuleContext(TestFileParser.BooleanArgContext, 0) def stringArg(self): - return self.getTypedRuleContext(TestFileParser.StringArgContext,0) - + return self.getTypedRuleContext(TestFileParser.StringArgContext, 0) def decimalArg(self): - return self.getTypedRuleContext(TestFileParser.DecimalArgContext,0) - + return self.getTypedRuleContext(TestFileParser.DecimalArgContext, 0) def dateArg(self): - return self.getTypedRuleContext(TestFileParser.DateArgContext,0) - + return self.getTypedRuleContext(TestFileParser.DateArgContext, 0) def timeArg(self): - return self.getTypedRuleContext(TestFileParser.TimeArgContext,0) - + return self.getTypedRuleContext(TestFileParser.TimeArgContext, 0) def timestampArg(self): - return self.getTypedRuleContext(TestFileParser.TimestampArgContext,0) - + return self.getTypedRuleContext(TestFileParser.TimestampArgContext, 0) def timestampTzArg(self): - return self.getTypedRuleContext(TestFileParser.TimestampTzArgContext,0) - + return self.getTypedRuleContext(TestFileParser.TimestampTzArgContext, 0) def intervalYearArg(self): - return self.getTypedRuleContext(TestFileParser.IntervalYearArgContext,0) - + return self.getTypedRuleContext(TestFileParser.IntervalYearArgContext, 0) def intervalDayArg(self): - return self.getTypedRuleContext(TestFileParser.IntervalDayArgContext,0) - + return self.getTypedRuleContext(TestFileParser.IntervalDayArgContext, 0) def getRuleIndex(self): return TestFileParser.RULE_argument - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArgument" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArgument"): listener.enterArgument(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArgument" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArgument"): listener.exitArgument(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArgument" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArgument"): return visitor.visitArgument(self) else: return visitor.visitChildren(self) - - - def argument(self): localctx = TestFileParser.ArgumentContext(self, self._ctx, self.state) @@ -1070,7 +4479,7 @@ def argument(self): try: self.state = 162 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,6,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 6, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 146 @@ -1167,7 +4576,6 @@ def argument(self): self.intervalDayArg() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1176,11 +4584,12 @@ def argument(self): self.exitRule() return localctx - class NumericLiteralContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1196,33 +4605,30 @@ def FLOAT_LITERAL(self): def getRuleIndex(self): return TestFileParser.RULE_numericLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNumericLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNumericLiteral"): listener.enterNumericLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNumericLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNumericLiteral"): listener.exitNumericLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNumericLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNumericLiteral"): return visitor.visitNumericLiteral(self) else: return visitor.visitChildren(self) - - - def numericLiteral(self): localctx = TestFileParser.NumericLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_numericLiteral) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 164 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 114688) != 0)): + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 114688) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -1235,11 +4641,12 @@ def numericLiteral(self): self.exitRule() return localctx - class NullArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1250,29 +4657,25 @@ def DOUBLE_COLON(self): return self.getToken(TestFileParser.DOUBLE_COLON, 0) def datatype(self): - return self.getTypedRuleContext(TestFileParser.DatatypeContext,0) - + return self.getTypedRuleContext(TestFileParser.DatatypeContext, 0) def getRuleIndex(self): return TestFileParser.RULE_nullArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNullArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNullArg"): listener.enterNullArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNullArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNullArg"): listener.exitNullArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNullArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNullArg"): return visitor.visitNullArg(self) else: return visitor.visitChildren(self) - - - def nullArg(self): localctx = TestFileParser.NullArgContext(self, self._ctx, self.state) @@ -1293,11 +4696,12 @@ def nullArg(self): self.exitRule() return localctx - class I8ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1313,23 +4717,20 @@ def I8(self): def getRuleIndex(self): return TestFileParser.RULE_i8Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI8Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI8Arg"): listener.enterI8Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI8Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI8Arg"): listener.exitI8Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI8Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI8Arg"): return visitor.visitI8Arg(self) else: return visitor.visitChildren(self) - - - def i8Arg(self): localctx = TestFileParser.I8ArgContext(self, self._ctx, self.state) @@ -1350,11 +4751,12 @@ def i8Arg(self): self.exitRule() return localctx - class I16ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1370,23 +4772,20 @@ def I16(self): def getRuleIndex(self): return TestFileParser.RULE_i16Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI16Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI16Arg"): listener.enterI16Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI16Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI16Arg"): listener.exitI16Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI16Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI16Arg"): return visitor.visitI16Arg(self) else: return visitor.visitChildren(self) - - - def i16Arg(self): localctx = TestFileParser.I16ArgContext(self, self._ctx, self.state) @@ -1407,11 +4806,12 @@ def i16Arg(self): self.exitRule() return localctx - class I32ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1427,23 +4827,20 @@ def I32(self): def getRuleIndex(self): return TestFileParser.RULE_i32Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI32Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI32Arg"): listener.enterI32Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI32Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI32Arg"): listener.exitI32Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI32Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI32Arg"): return visitor.visitI32Arg(self) else: return visitor.visitChildren(self) - - - def i32Arg(self): localctx = TestFileParser.I32ArgContext(self, self._ctx, self.state) @@ -1464,11 +4861,12 @@ def i32Arg(self): self.exitRule() return localctx - class I64ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1484,23 +4882,20 @@ def I64(self): def getRuleIndex(self): return TestFileParser.RULE_i64Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI64Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI64Arg"): listener.enterI64Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI64Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI64Arg"): listener.exitI64Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI64Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI64Arg"): return visitor.visitI64Arg(self) else: return visitor.visitChildren(self) - - - def i64Arg(self): localctx = TestFileParser.I64ArgContext(self, self._ctx, self.state) @@ -1521,17 +4916,17 @@ def i64Arg(self): self.exitRule() return localctx - class Fp32ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def numericLiteral(self): - return self.getTypedRuleContext(TestFileParser.NumericLiteralContext,0) - + return self.getTypedRuleContext(TestFileParser.NumericLiteralContext, 0) def DOUBLE_COLON(self): return self.getToken(TestFileParser.DOUBLE_COLON, 0) @@ -1542,23 +4937,20 @@ def FP32(self): def getRuleIndex(self): return TestFileParser.RULE_fp32Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp32Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp32Arg"): listener.enterFp32Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp32Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp32Arg"): listener.exitFp32Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp32Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp32Arg"): return visitor.visitFp32Arg(self) else: return visitor.visitChildren(self) - - - def fp32Arg(self): localctx = TestFileParser.Fp32ArgContext(self, self._ctx, self.state) @@ -1579,17 +4971,17 @@ def fp32Arg(self): self.exitRule() return localctx - class Fp64ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def numericLiteral(self): - return self.getTypedRuleContext(TestFileParser.NumericLiteralContext,0) - + return self.getTypedRuleContext(TestFileParser.NumericLiteralContext, 0) def DOUBLE_COLON(self): return self.getToken(TestFileParser.DOUBLE_COLON, 0) @@ -1600,23 +4992,20 @@ def FP64(self): def getRuleIndex(self): return TestFileParser.RULE_fp64Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp64Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp64Arg"): listener.enterFp64Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp64Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp64Arg"): listener.exitFp64Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp64Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp64Arg"): return visitor.visitFp64Arg(self) else: return visitor.visitChildren(self) - - - def fp64Arg(self): localctx = TestFileParser.Fp64ArgContext(self, self._ctx, self.state) @@ -1637,45 +5026,41 @@ def fp64Arg(self): self.exitRule() return localctx - class DecimalArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def numericLiteral(self): - return self.getTypedRuleContext(TestFileParser.NumericLiteralContext,0) - + return self.getTypedRuleContext(TestFileParser.NumericLiteralContext, 0) def DOUBLE_COLON(self): return self.getToken(TestFileParser.DOUBLE_COLON, 0) def decimalType(self): - return self.getTypedRuleContext(TestFileParser.DecimalTypeContext,0) - + return self.getTypedRuleContext(TestFileParser.DecimalTypeContext, 0) def getRuleIndex(self): return TestFileParser.RULE_decimalArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDecimalArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDecimalArg"): listener.enterDecimalArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDecimalArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDecimalArg"): listener.exitDecimalArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDecimalArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDecimalArg"): return visitor.visitDecimalArg(self) else: return visitor.visitChildren(self) - - - def decimalArg(self): localctx = TestFileParser.DecimalArgContext(self, self._ctx, self.state) @@ -1696,11 +5081,12 @@ def decimalArg(self): self.exitRule() return localctx - class BooleanArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1716,23 +5102,20 @@ def Bool(self): def getRuleIndex(self): return TestFileParser.RULE_booleanArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBooleanArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBooleanArg"): listener.enterBooleanArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBooleanArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBooleanArg"): listener.exitBooleanArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBooleanArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanArg"): return visitor.visitBooleanArg(self) else: return visitor.visitChildren(self) - - - def booleanArg(self): localctx = TestFileParser.BooleanArgContext(self, self._ctx, self.state) @@ -1753,11 +5136,12 @@ def booleanArg(self): self.exitRule() return localctx - class StringArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1773,23 +5157,20 @@ def Str(self): def getRuleIndex(self): return TestFileParser.RULE_stringArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStringArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringArg"): listener.enterStringArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStringArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringArg"): listener.exitStringArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStringArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringArg"): return visitor.visitStringArg(self) else: return visitor.visitChildren(self) - - - def stringArg(self): localctx = TestFileParser.StringArgContext(self, self._ctx, self.state) @@ -1810,11 +5191,12 @@ def stringArg(self): self.exitRule() return localctx - class DateArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1830,23 +5212,20 @@ def Date(self): def getRuleIndex(self): return TestFileParser.RULE_dateArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDateArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateArg"): listener.enterDateArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDateArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateArg"): listener.exitDateArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDateArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateArg"): return visitor.visitDateArg(self) else: return visitor.visitChildren(self) - - - def dateArg(self): localctx = TestFileParser.DateArgContext(self, self._ctx, self.state) @@ -1867,11 +5246,12 @@ def dateArg(self): self.exitRule() return localctx - class TimeArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1887,23 +5267,20 @@ def Time(self): def getRuleIndex(self): return TestFileParser.RULE_timeArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeArg"): listener.enterTimeArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeArg"): listener.exitTimeArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeArg"): return visitor.visitTimeArg(self) else: return visitor.visitChildren(self) - - - def timeArg(self): localctx = TestFileParser.TimeArgContext(self, self._ctx, self.state) @@ -1924,11 +5301,12 @@ def timeArg(self): self.exitRule() return localctx - class TimestampArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1944,23 +5322,20 @@ def Ts(self): def getRuleIndex(self): return TestFileParser.RULE_timestampArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestampArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestampArg"): listener.enterTimestampArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestampArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestampArg"): listener.exitTimestampArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestampArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestampArg"): return visitor.visitTimestampArg(self) else: return visitor.visitChildren(self) - - - def timestampArg(self): localctx = TestFileParser.TimestampArgContext(self, self._ctx, self.state) @@ -1981,11 +5356,12 @@ def timestampArg(self): self.exitRule() return localctx - class TimestampTzArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -2001,23 +5377,20 @@ def TsTZ(self): def getRuleIndex(self): return TestFileParser.RULE_timestampTzArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestampTzArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestampTzArg"): listener.enterTimestampTzArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestampTzArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestampTzArg"): listener.exitTimestampTzArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestampTzArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestampTzArg"): return visitor.visitTimestampTzArg(self) else: return visitor.visitChildren(self) - - - def timestampTzArg(self): localctx = TestFileParser.TimestampTzArgContext(self, self._ctx, self.state) @@ -2038,11 +5411,12 @@ def timestampTzArg(self): self.exitRule() return localctx - class IntervalYearArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -2058,23 +5432,20 @@ def IYear(self): def getRuleIndex(self): return TestFileParser.RULE_intervalYearArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalYearArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalYearArg"): listener.enterIntervalYearArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalYearArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalYearArg"): listener.exitIntervalYearArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalYearArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalYearArg"): return visitor.visitIntervalYearArg(self) else: return visitor.visitChildren(self) - - - def intervalYearArg(self): localctx = TestFileParser.IntervalYearArgContext(self, self._ctx, self.state) @@ -2095,11 +5466,12 @@ def intervalYearArg(self): self.exitRule() return localctx - class IntervalDayArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -2115,23 +5487,20 @@ def IDay(self): def getRuleIndex(self): return TestFileParser.RULE_intervalDayArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalDayArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalDayArg"): listener.enterIntervalDayArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalDayArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalDayArg"): listener.exitIntervalDayArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalDayArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalDayArg"): return visitor.visitIntervalDayArg(self) else: return visitor.visitChildren(self) - - - def intervalDayArg(self): localctx = TestFileParser.IntervalDayArgContext(self, self._ctx, self.state) @@ -2152,15 +5521,16 @@ def intervalDayArg(self): self.exitRule() return localctx - class IntervalYearLiteralContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.years = None # Token - self.months = None # Token + self.years = None # Token + self.months = None # Token def PERIOD_PREFIX(self): return self.getToken(TestFileParser.PERIOD_PREFIX, 0) @@ -2168,7 +5538,7 @@ def PERIOD_PREFIX(self): def YEAR_SUFFIX(self): return self.getToken(TestFileParser.YEAR_SUFFIX, 0) - def INTEGER_LITERAL(self, i:int=None): + def INTEGER_LITERAL(self, i: int = None): if i is None: return self.getTokens(TestFileParser.INTEGER_LITERAL) else: @@ -2180,32 +5550,31 @@ def M_SUFFIX(self): def getRuleIndex(self): return TestFileParser.RULE_intervalYearLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalYearLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalYearLiteral"): listener.enterIntervalYearLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalYearLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalYearLiteral"): listener.exitIntervalYearLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalYearLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalYearLiteral"): return visitor.visitIntervalYearLiteral(self) else: return visitor.visitChildren(self) - - - def intervalYearLiteral(self): - localctx = TestFileParser.IntervalYearLiteralContext(self, self._ctx, self.state) + localctx = TestFileParser.IntervalYearLiteralContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 54, self.RULE_intervalYearLiteral) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 241 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,8,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 230 @@ -2218,13 +5587,12 @@ def intervalYearLiteral(self): self.state = 236 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 234 localctx.months = self.match(TestFileParser.INTEGER_LITERAL) self.state = 235 self.match(TestFileParser.M_SUFFIX) - pass elif la_ == 2: @@ -2238,7 +5606,6 @@ def intervalYearLiteral(self): self.match(TestFileParser.M_SUFFIX) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2247,14 +5614,15 @@ def intervalYearLiteral(self): self.exitRule() return localctx - class IntervalDayLiteralContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.days = None # Token + self.days = None # Token def PERIOD_PREFIX(self): return self.getToken(TestFileParser.PERIOD_PREFIX, 0) @@ -2269,38 +5637,34 @@ def TIME_PREFIX(self): return self.getToken(TestFileParser.TIME_PREFIX, 0) def timeInterval(self): - return self.getTypedRuleContext(TestFileParser.TimeIntervalContext,0) - + return self.getTypedRuleContext(TestFileParser.TimeIntervalContext, 0) def getRuleIndex(self): return TestFileParser.RULE_intervalDayLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalDayLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalDayLiteral"): listener.enterIntervalDayLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalDayLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalDayLiteral"): listener.exitIntervalDayLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalDayLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalDayLiteral"): return visitor.visitIntervalDayLiteral(self) else: return visitor.visitChildren(self) - - - def intervalDayLiteral(self): localctx = TestFileParser.IntervalDayLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 56, self.RULE_intervalDayLiteral) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 254 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,10,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 10, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 243 @@ -2313,13 +5677,12 @@ def intervalDayLiteral(self): self.state = 249 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==23: + if _la == 23: self.state = 247 self.match(TestFileParser.TIME_PREFIX) self.state = 248 self.timeInterval() - pass elif la_ == 2: @@ -2332,7 +5695,6 @@ def intervalDayLiteral(self): self.timeInterval() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2341,22 +5703,23 @@ def intervalDayLiteral(self): self.exitRule() return localctx - class TimeIntervalContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.hours = None # Token - self.minutes = None # Token - self.seconds = None # Token - self.fractionalSeconds = None # Token + self.hours = None # Token + self.minutes = None # Token + self.seconds = None # Token + self.fractionalSeconds = None # Token def HOUR_SUFFIX(self): return self.getToken(TestFileParser.HOUR_SUFFIX, 0) - def INTEGER_LITERAL(self, i:int=None): + def INTEGER_LITERAL(self, i: int = None): if i is None: return self.getTokens(TestFileParser.INTEGER_LITERAL) else: @@ -2374,32 +5737,29 @@ def FRACTIONAL_SECOND_SUFFIX(self): def getRuleIndex(self): return TestFileParser.RULE_timeInterval - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeInterval" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeInterval"): listener.enterTimeInterval(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeInterval" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeInterval"): listener.exitTimeInterval(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeInterval" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeInterval"): return visitor.visitTimeInterval(self) else: return visitor.visitChildren(self) - - - def timeInterval(self): localctx = TestFileParser.TimeIntervalContext(self, self._ctx, self.state) self.enterRule(localctx, 58, self.RULE_timeInterval) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 288 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,17,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 17, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 256 @@ -2408,34 +5768,33 @@ def timeInterval(self): self.match(TestFileParser.HOUR_SUFFIX) self.state = 260 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,11,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 11, self._ctx) if la_ == 1: self.state = 258 localctx.minutes = self.match(TestFileParser.INTEGER_LITERAL) self.state = 259 self.match(TestFileParser.M_SUFFIX) - self.state = 264 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,12,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) if la_ == 1: self.state = 262 localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) self.state = 263 self.match(TestFileParser.SECOND_SUFFIX) - self.state = 268 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 266 - localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) + localctx.fractionalSeconds = self.match( + TestFileParser.INTEGER_LITERAL + ) self.state = 267 self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) - pass elif la_ == 2: @@ -2446,24 +5805,24 @@ def timeInterval(self): self.match(TestFileParser.M_SUFFIX) self.state = 274 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,14,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 14, self._ctx) if la_ == 1: self.state = 272 localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) self.state = 273 self.match(TestFileParser.SECOND_SUFFIX) - self.state = 278 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 276 - localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) + localctx.fractionalSeconds = self.match( + TestFileParser.INTEGER_LITERAL + ) self.state = 277 self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) - pass elif la_ == 3: @@ -2475,13 +5834,14 @@ def timeInterval(self): self.state = 284 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 282 - localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) + localctx.fractionalSeconds = self.match( + TestFileParser.INTEGER_LITERAL + ) self.state = 283 self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) - pass elif la_ == 4: @@ -2492,7 +5852,6 @@ def timeInterval(self): self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2501,42 +5860,38 @@ def timeInterval(self): self.exitRule() return localctx - class DatatypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def scalarType(self): - return self.getTypedRuleContext(TestFileParser.ScalarTypeContext,0) - + return self.getTypedRuleContext(TestFileParser.ScalarTypeContext, 0) def parameterizedType(self): - return self.getTypedRuleContext(TestFileParser.ParameterizedTypeContext,0) - + return self.getTypedRuleContext(TestFileParser.ParameterizedTypeContext, 0) def getRuleIndex(self): return TestFileParser.RULE_datatype - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDatatype" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDatatype"): listener.enterDatatype(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDatatype" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDatatype"): listener.exitDatatype(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDatatype" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDatatype"): return visitor.visitDatatype(self) else: return visitor.visitChildren(self) - - - def datatype(self): localctx = TestFileParser.DatatypeContext(self, self._ctx, self.state) @@ -2545,7 +5900,25 @@ def datatype(self): self.state = 292 self._errHandler.sync(self) token = self._input.LA(1) - if token in [41, 42, 43, 44, 45, 46, 48, 51, 52, 55, 67, 68, 69, 71, 72, 73, 74]: + if token in [ + 41, + 42, + 43, + 44, + 45, + 46, + 48, + 51, + 52, + 55, + 67, + 68, + 69, + 71, + 72, + 73, + 74, + ]: self.enterOuterAlt(localctx, 1) self.state = 290 self.scalarType() @@ -2566,435 +5939,449 @@ def datatype(self): self.exitRule() return localctx - class ScalarTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_scalarType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DateContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Date(self): return self.getToken(TestFileParser.Date, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDate" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDate"): listener.enterDate(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDate" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDate"): listener.exitDate(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDate" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDate"): return visitor.visitDate(self) else: return visitor.visitChildren(self) - class StringContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Str(self): return self.getToken(TestFileParser.Str, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterString" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterString"): listener.enterString(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitString" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitString"): listener.exitString(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitString" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitString"): return visitor.visitString(self) else: return visitor.visitChildren(self) - class I64Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I64(self): return self.getToken(TestFileParser.I64, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI64" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI64"): listener.enterI64(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI64" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI64"): listener.exitI64(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI64" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI64"): return visitor.visitI64(self) else: return visitor.visitChildren(self) - class UserDefinedContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def UserDefined(self): return self.getToken(TestFileParser.UserDefined, 0) + def IDENTIFIER(self): return self.getToken(TestFileParser.IDENTIFIER, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUserDefined" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUserDefined"): listener.enterUserDefined(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUserDefined" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUserDefined"): listener.exitUserDefined(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUserDefined" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUserDefined"): return visitor.visitUserDefined(self) else: return visitor.visitChildren(self) - class I32Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I32(self): return self.getToken(TestFileParser.I32, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI32" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI32"): listener.enterI32(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI32" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI32"): listener.exitI32(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI32" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI32"): return visitor.visitI32(self) else: return visitor.visitChildren(self) - class IntervalYearContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def IYear(self): return self.getToken(TestFileParser.IYear, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalYear" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalYear"): listener.enterIntervalYear(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalYear" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalYear"): listener.exitIntervalYear(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalYear" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalYear"): return visitor.visitIntervalYear(self) else: return visitor.visitChildren(self) - class UuidContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def UUID(self): return self.getToken(TestFileParser.UUID, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUuid" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUuid"): listener.enterUuid(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUuid" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUuid"): listener.exitUuid(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUuid" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUuid"): return visitor.visitUuid(self) else: return visitor.visitChildren(self) - class I8Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I8(self): return self.getToken(TestFileParser.I8, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI8" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI8"): listener.enterI8(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI8" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI8"): listener.exitI8(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI8" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI8"): return visitor.visitI8(self) else: return visitor.visitChildren(self) - class I16Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I16(self): return self.getToken(TestFileParser.I16, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI16" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI16"): listener.enterI16(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI16" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI16"): listener.exitI16(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI16" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI16"): return visitor.visitI16(self) else: return visitor.visitChildren(self) - class BinaryContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Binary(self): return self.getToken(TestFileParser.Binary, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBinary" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBinary"): listener.enterBinary(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBinary" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBinary"): listener.exitBinary(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBinary" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBinary"): return visitor.visitBinary(self) else: return visitor.visitChildren(self) - class IntervalDayContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def IDay(self): return self.getToken(TestFileParser.IDay, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalDay" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalDay"): listener.enterIntervalDay(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalDay" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalDay"): listener.exitIntervalDay(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalDay" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalDay"): return visitor.visitIntervalDay(self) else: return visitor.visitChildren(self) - class Fp64Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def FP64(self): return self.getToken(TestFileParser.FP64, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp64" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp64"): listener.enterFp64(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp64" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp64"): listener.exitFp64(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp64" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp64"): return visitor.visitFp64(self) else: return visitor.visitChildren(self) - class Fp32Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def FP32(self): return self.getToken(TestFileParser.FP32, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp32" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp32"): listener.enterFp32(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp32" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp32"): listener.exitFp32(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp32" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp32"): return visitor.visitFp32(self) else: return visitor.visitChildren(self) - class TimeContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Time(self): return self.getToken(TestFileParser.Time, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTime" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTime"): listener.enterTime(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTime" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTime"): listener.exitTime(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTime" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTime"): return visitor.visitTime(self) else: return visitor.visitChildren(self) - class BooleanContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Bool(self): return self.getToken(TestFileParser.Bool, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBoolean" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBoolean"): listener.enterBoolean(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBoolean" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBoolean"): listener.exitBoolean(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBoolean" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBoolean"): return visitor.visitBoolean(self) else: return visitor.visitChildren(self) - class TimestampContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Ts(self): return self.getToken(TestFileParser.Ts, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestamp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestamp"): listener.enterTimestamp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestamp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestamp"): listener.exitTimestamp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestamp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestamp"): return visitor.visitTimestamp(self) else: return visitor.visitChildren(self) - class TimestampTzContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def TsTZ(self): return self.getToken(TestFileParser.TsTZ, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestampTz" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestampTz"): listener.enterTimestampTz(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestampTz" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestampTz"): listener.exitTimestampTz(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestampTz" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestampTz"): return visitor.visitTimestampTz(self) else: return visitor.visitChildren(self) - - def scalarType(self): localctx = TestFileParser.ScalarTypeContext(self, self._ctx, self.state) @@ -3118,65 +6505,65 @@ def scalarType(self): self.exitRule() return localctx - class FixedCharTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_fixedCharType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class FixedCharContext(FixedCharTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.FixedCharTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.FixedCharTypeContext super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext + self.isnull = None # Token + self.len_ = None # NumericParameterContext self.copyFrom(ctx) def FChar(self): return self.getToken(TestFileParser.FChar, 0) + def O_ANGLE_BRACKET(self): return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) def QMARK(self): return self.getToken(TestFileParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFixedChar" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFixedChar"): listener.enterFixedChar(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFixedChar" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFixedChar"): listener.exitFixedChar(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFixedChar" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFixedChar"): return visitor.visitFixedChar(self) else: return visitor.visitChildren(self) - - def fixedCharType(self): localctx = TestFileParser.FixedCharTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 64, self.RULE_fixedCharType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = TestFileParser.FixedCharContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3185,11 +6572,10 @@ def fixedCharType(self): self.state = 316 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==92: + if _la == 92: self.state = 315 localctx.isnull = self.match(TestFileParser.QMARK) - self.state = 318 self.match(TestFileParser.O_ANGLE_BRACKET) self.state = 319 @@ -3204,65 +6590,65 @@ def fixedCharType(self): self.exitRule() return localctx - class VarCharTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_varCharType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class VarCharContext(VarCharTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.VarCharTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.VarCharTypeContext super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext + self.isnull = None # Token + self.len_ = None # NumericParameterContext self.copyFrom(ctx) def VChar(self): return self.getToken(TestFileParser.VChar, 0) + def O_ANGLE_BRACKET(self): return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) def QMARK(self): return self.getToken(TestFileParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVarChar" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVarChar"): listener.enterVarChar(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVarChar" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVarChar"): listener.exitVarChar(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVarChar" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVarChar"): return visitor.visitVarChar(self) else: return visitor.visitChildren(self) - - def varCharType(self): localctx = TestFileParser.VarCharTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 66, self.RULE_varCharType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = TestFileParser.VarCharContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3271,11 +6657,10 @@ def varCharType(self): self.state = 324 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==92: + if _la == 92: self.state = 323 localctx.isnull = self.match(TestFileParser.QMARK) - self.state = 326 self.match(TestFileParser.O_ANGLE_BRACKET) self.state = 327 @@ -3290,65 +6675,65 @@ def varCharType(self): self.exitRule() return localctx - class FixedBinaryTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_fixedBinaryType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class FixedBinaryContext(FixedBinaryTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.FixedBinaryTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.FixedBinaryTypeContext super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext + self.isnull = None # Token + self.len_ = None # NumericParameterContext self.copyFrom(ctx) def FBin(self): return self.getToken(TestFileParser.FBin, 0) + def O_ANGLE_BRACKET(self): return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) def QMARK(self): return self.getToken(TestFileParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFixedBinary" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFixedBinary"): listener.enterFixedBinary(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFixedBinary" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFixedBinary"): listener.exitFixedBinary(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFixedBinary" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFixedBinary"): return visitor.visitFixedBinary(self) else: return visitor.visitChildren(self) - - def fixedBinaryType(self): localctx = TestFileParser.FixedBinaryTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 68, self.RULE_fixedBinaryType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = TestFileParser.FixedBinaryContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3357,11 +6742,10 @@ def fixedBinaryType(self): self.state = 332 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==92: + if _la == 92: self.state = 331 localctx.isnull = self.match(TestFileParser.QMARK) - self.state = 334 self.match(TestFileParser.O_ANGLE_BRACKET) self.state = 335 @@ -3376,71 +6760,74 @@ def fixedBinaryType(self): self.exitRule() return localctx - class DecimalTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_decimalType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DecimalContext(DecimalTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.DecimalTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.DecimalTypeContext super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext - self.scale = None # NumericParameterContext + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.scale = None # NumericParameterContext self.copyFrom(ctx) def Dec(self): return self.getToken(TestFileParser.Dec, 0) + def O_ANGLE_BRACKET(self): return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def COMMA(self): return self.getToken(TestFileParser.COMMA, 0) + def C_ANGLE_BRACKET(self): return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def QMARK(self): return self.getToken(TestFileParser.QMARK, 0) - def numericParameter(self, i:int=None): + + def numericParameter(self, i: int = None): if i is None: return self.getTypedRuleContexts(TestFileParser.NumericParameterContext) else: - return self.getTypedRuleContext(TestFileParser.NumericParameterContext,i) - + return self.getTypedRuleContext( + TestFileParser.NumericParameterContext, i + ) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDecimal" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDecimal"): listener.enterDecimal(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDecimal" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDecimal"): listener.exitDecimal(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDecimal" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDecimal"): return visitor.visitDecimal(self) else: return visitor.visitChildren(self) - - def decimalType(self): localctx = TestFileParser.DecimalTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 70, self.RULE_decimalType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = TestFileParser.DecimalContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3449,15 +6836,14 @@ def decimalType(self): self.state = 340 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==92: + if _la == 92: self.state = 339 localctx.isnull = self.match(TestFileParser.QMARK) - self.state = 348 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==83: + if _la == 83: self.state = 342 self.match(TestFileParser.O_ANGLE_BRACKET) self.state = 343 @@ -3469,7 +6855,6 @@ def decimalType(self): self.state = 346 self.match(TestFileParser.C_ANGLE_BRACKET) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3478,65 +6863,67 @@ def decimalType(self): self.exitRule() return localctx - class PrecisionTimestampTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_precisionTimestampType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class PrecisionTimestampContext(PrecisionTimestampTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.PrecisionTimestampTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.PrecisionTimestampTypeContext super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext + self.isnull = None # Token + self.precision = None # NumericParameterContext self.copyFrom(ctx) def PTs(self): return self.getToken(TestFileParser.PTs, 0) + def O_ANGLE_BRACKET(self): return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) def QMARK(self): return self.getToken(TestFileParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPrecisionTimestamp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPrecisionTimestamp"): listener.enterPrecisionTimestamp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPrecisionTimestamp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPrecisionTimestamp"): listener.exitPrecisionTimestamp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPrecisionTimestamp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPrecisionTimestamp"): return visitor.visitPrecisionTimestamp(self) else: return visitor.visitChildren(self) - - def precisionTimestampType(self): - localctx = TestFileParser.PrecisionTimestampTypeContext(self, self._ctx, self.state) + localctx = TestFileParser.PrecisionTimestampTypeContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 72, self.RULE_precisionTimestampType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = TestFileParser.PrecisionTimestampContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3545,11 +6932,10 @@ def precisionTimestampType(self): self.state = 352 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==92: + if _la == 92: self.state = 351 localctx.isnull = self.match(TestFileParser.QMARK) - self.state = 354 self.match(TestFileParser.O_ANGLE_BRACKET) self.state = 355 @@ -3564,65 +6950,67 @@ def precisionTimestampType(self): self.exitRule() return localctx - class PrecisionTimestampTZTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_precisionTimestampTZType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class PrecisionTimestampTZContext(PrecisionTimestampTZTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.PrecisionTimestampTZTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.PrecisionTimestampTZTypeContext super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext + self.isnull = None # Token + self.precision = None # NumericParameterContext self.copyFrom(ctx) def PTsTZ(self): return self.getToken(TestFileParser.PTsTZ, 0) + def O_ANGLE_BRACKET(self): return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext,0) + return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) def QMARK(self): return self.getToken(TestFileParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPrecisionTimestampTZ" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPrecisionTimestampTZ"): listener.enterPrecisionTimestampTZ(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPrecisionTimestampTZ" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPrecisionTimestampTZ"): listener.exitPrecisionTimestampTZ(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPrecisionTimestampTZ" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPrecisionTimestampTZ"): return visitor.visitPrecisionTimestampTZ(self) else: return visitor.visitChildren(self) - - def precisionTimestampTZType(self): - localctx = TestFileParser.PrecisionTimestampTZTypeContext(self, self._ctx, self.state) + localctx = TestFileParser.PrecisionTimestampTZTypeContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 74, self.RULE_precisionTimestampTZType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = TestFileParser.PrecisionTimestampTZContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3631,11 +7019,10 @@ def precisionTimestampTZType(self): self.state = 360 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==92: + if _la == 92: self.state = 359 localctx.isnull = self.match(TestFileParser.QMARK) - self.state = 362 self.match(TestFileParser.O_ANGLE_BRACKET) self.state = 363 @@ -3650,58 +7037,54 @@ def precisionTimestampTZType(self): self.exitRule() return localctx - class ParameterizedTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def fixedCharType(self): - return self.getTypedRuleContext(TestFileParser.FixedCharTypeContext,0) - + return self.getTypedRuleContext(TestFileParser.FixedCharTypeContext, 0) def varCharType(self): - return self.getTypedRuleContext(TestFileParser.VarCharTypeContext,0) - + return self.getTypedRuleContext(TestFileParser.VarCharTypeContext, 0) def fixedBinaryType(self): - return self.getTypedRuleContext(TestFileParser.FixedBinaryTypeContext,0) - + return self.getTypedRuleContext(TestFileParser.FixedBinaryTypeContext, 0) def decimalType(self): - return self.getTypedRuleContext(TestFileParser.DecimalTypeContext,0) - + return self.getTypedRuleContext(TestFileParser.DecimalTypeContext, 0) def precisionTimestampType(self): - return self.getTypedRuleContext(TestFileParser.PrecisionTimestampTypeContext,0) - + return self.getTypedRuleContext( + TestFileParser.PrecisionTimestampTypeContext, 0 + ) def precisionTimestampTZType(self): - return self.getTypedRuleContext(TestFileParser.PrecisionTimestampTZTypeContext,0) - + return self.getTypedRuleContext( + TestFileParser.PrecisionTimestampTZTypeContext, 0 + ) def getRuleIndex(self): return TestFileParser.RULE_parameterizedType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParameterizedType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParameterizedType"): listener.enterParameterizedType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParameterizedType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParameterizedType"): listener.exitParameterizedType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParameterizedType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameterizedType"): return visitor.visitParameterizedType(self) else: return visitor.visitChildren(self) - - - def parameterizedType(self): localctx = TestFileParser.ParameterizedTypeContext(self, self._ctx, self.state) @@ -3751,49 +7134,46 @@ def parameterizedType(self): self.exitRule() return localctx - class NumericParameterContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return TestFileParser.RULE_numericParameter - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class IntegerLiteralContext(NumericParameterContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a TestFileParser.NumericParameterContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a TestFileParser.NumericParameterContext super().__init__(parser) self.copyFrom(ctx) def INTEGER_LITERAL(self): return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntegerLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntegerLiteral"): listener.enterIntegerLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntegerLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntegerLiteral"): listener.exitIntegerLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntegerLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntegerLiteral"): return visitor.visitIntegerLiteral(self) else: return visitor.visitChildren(self) - - def numericParameter(self): localctx = TestFileParser.NumericParameterContext(self, self._ctx, self.state) @@ -3811,11 +7191,12 @@ def numericParameter(self): self.exitRule() return localctx - class SubstraitErrorContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -3828,33 +7209,30 @@ def UNDEFINED_RESULT(self): def getRuleIndex(self): return TestFileParser.RULE_substraitError - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSubstraitError" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSubstraitError"): listener.enterSubstraitError(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSubstraitError" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSubstraitError"): listener.exitSubstraitError(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSubstraitError" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubstraitError"): return visitor.visitSubstraitError(self) else: return visitor.visitChildren(self) - - - def substraitError(self): localctx = TestFileParser.SubstraitErrorContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_substraitError) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 376 _la = self._input.LA(1) - if not(_la==5 or _la==6): + if not (_la == 5 or _la == 6): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3867,45 +7245,41 @@ def substraitError(self): self.exitRule() return localctx - class Func_optionContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def option_name(self): - return self.getTypedRuleContext(TestFileParser.Option_nameContext,0) - + return self.getTypedRuleContext(TestFileParser.Option_nameContext, 0) def COLON(self): return self.getToken(TestFileParser.COLON, 0) def option_value(self): - return self.getTypedRuleContext(TestFileParser.Option_valueContext,0) - + return self.getTypedRuleContext(TestFileParser.Option_valueContext, 0) def getRuleIndex(self): return TestFileParser.RULE_func_option - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunc_option" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunc_option"): listener.enterFunc_option(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunc_option" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunc_option"): listener.exitFunc_option(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunc_option" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunc_option"): return visitor.visitFunc_option(self) else: return visitor.visitChildren(self) - - - def func_option(self): localctx = TestFileParser.Func_optionContext(self, self._ctx, self.state) @@ -3926,11 +7300,12 @@ def func_option(self): self.exitRule() return localctx - class Option_nameContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -3946,33 +7321,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return TestFileParser.RULE_option_name - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOption_name" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOption_name"): listener.enterOption_name(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOption_name" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOption_name"): listener.exitOption_name(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOption_name" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOption_name"): return visitor.visitOption_name(self) else: return visitor.visitChildren(self) - - - def option_name(self): localctx = TestFileParser.Option_nameContext(self, self._ctx, self.state) self.enterRule(localctx, 84, self.RULE_option_name) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 382 _la = self._input.LA(1) - if not(_la==7 or _la==8 or _la==82): + if not (_la == 7 or _la == 8 or _la == 82): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3985,11 +7357,12 @@ def option_name(self): self.exitRule() return localctx - class Option_valueContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -4011,33 +7384,30 @@ def NAN(self): def getRuleIndex(self): return TestFileParser.RULE_option_value - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOption_value" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOption_value"): listener.enterOption_value(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOption_value" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOption_value"): listener.exitOption_value(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOption_value" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOption_value"): return visitor.visitOption_value(self) else: return visitor.visitChildren(self) - - - def option_value(self): localctx = TestFileParser.Option_valueContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_option_value) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 384 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 15872) != 0)): + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 15872) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4050,22 +7420,22 @@ def option_value(self): self.exitRule() return localctx - class Func_optionsContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def func_option(self, i:int=None): + def func_option(self, i: int = None): if i is None: return self.getTypedRuleContexts(TestFileParser.Func_optionContext) else: - return self.getTypedRuleContext(TestFileParser.Func_optionContext,i) + return self.getTypedRuleContext(TestFileParser.Func_optionContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(TestFileParser.COMMA) else: @@ -4074,28 +7444,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return TestFileParser.RULE_func_options - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunc_options" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunc_options"): listener.enterFunc_options(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunc_options" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunc_options"): listener.exitFunc_options(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunc_options" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunc_options"): return visitor.visitFunc_options(self) else: return visitor.visitChildren(self) - - - def func_options(self): localctx = TestFileParser.Func_optionsContext(self, self._ctx, self.state) self.enterRule(localctx, 88, self.RULE_func_options) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 386 @@ -4103,7 +7470,7 @@ def func_options(self): self.state = 391 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==89: + while _la == 89: self.state = 387 self.match(TestFileParser.COMMA) self.state = 388 @@ -4119,8 +7486,3 @@ def func_options(self): finally: self.exitRule() return localctx - - - - - diff --git a/tests/coverage/antlr_parser/TestFileParserListener.py b/tests/coverage/antlr_parser/TestFileParserListener.py index c419b9f5d..62b384dce 100644 --- a/tests/coverage/antlr_parser/TestFileParserListener.py +++ b/tests/coverage/antlr_parser/TestFileParserListener.py @@ -1,561 +1,506 @@ # Generated from TestFileParser.g4 by ANTLR 4.13.2 from antlr4 import * + if "." in __name__: from .TestFileParser import TestFileParser else: from TestFileParser import TestFileParser + # This class defines a complete listener for a parse tree produced by TestFileParser. class TestFileParserListener(ParseTreeListener): # Enter a parse tree produced by TestFileParser#doc. - def enterDoc(self, ctx:TestFileParser.DocContext): + def enterDoc(self, ctx: TestFileParser.DocContext): pass # Exit a parse tree produced by TestFileParser#doc. - def exitDoc(self, ctx:TestFileParser.DocContext): + def exitDoc(self, ctx: TestFileParser.DocContext): pass - # Enter a parse tree produced by TestFileParser#header. - def enterHeader(self, ctx:TestFileParser.HeaderContext): + def enterHeader(self, ctx: TestFileParser.HeaderContext): pass # Exit a parse tree produced by TestFileParser#header. - def exitHeader(self, ctx:TestFileParser.HeaderContext): + def exitHeader(self, ctx: TestFileParser.HeaderContext): pass - # Enter a parse tree produced by TestFileParser#version. - def enterVersion(self, ctx:TestFileParser.VersionContext): + def enterVersion(self, ctx: TestFileParser.VersionContext): pass # Exit a parse tree produced by TestFileParser#version. - def exitVersion(self, ctx:TestFileParser.VersionContext): + def exitVersion(self, ctx: TestFileParser.VersionContext): pass - # Enter a parse tree produced by TestFileParser#include. - def enterInclude(self, ctx:TestFileParser.IncludeContext): + def enterInclude(self, ctx: TestFileParser.IncludeContext): pass # Exit a parse tree produced by TestFileParser#include. - def exitInclude(self, ctx:TestFileParser.IncludeContext): + def exitInclude(self, ctx: TestFileParser.IncludeContext): pass - # Enter a parse tree produced by TestFileParser#testGroupDescription. - def enterTestGroupDescription(self, ctx:TestFileParser.TestGroupDescriptionContext): + def enterTestGroupDescription( + self, ctx: TestFileParser.TestGroupDescriptionContext + ): pass # Exit a parse tree produced by TestFileParser#testGroupDescription. - def exitTestGroupDescription(self, ctx:TestFileParser.TestGroupDescriptionContext): + def exitTestGroupDescription(self, ctx: TestFileParser.TestGroupDescriptionContext): pass - # Enter a parse tree produced by TestFileParser#testCase. - def enterTestCase(self, ctx:TestFileParser.TestCaseContext): + def enterTestCase(self, ctx: TestFileParser.TestCaseContext): pass # Exit a parse tree produced by TestFileParser#testCase. - def exitTestCase(self, ctx:TestFileParser.TestCaseContext): + def exitTestCase(self, ctx: TestFileParser.TestCaseContext): pass - # Enter a parse tree produced by TestFileParser#testGroup. - def enterTestGroup(self, ctx:TestFileParser.TestGroupContext): + def enterTestGroup(self, ctx: TestFileParser.TestGroupContext): pass # Exit a parse tree produced by TestFileParser#testGroup. - def exitTestGroup(self, ctx:TestFileParser.TestGroupContext): + def exitTestGroup(self, ctx: TestFileParser.TestGroupContext): pass - # Enter a parse tree produced by TestFileParser#arguments. - def enterArguments(self, ctx:TestFileParser.ArgumentsContext): + def enterArguments(self, ctx: TestFileParser.ArgumentsContext): pass # Exit a parse tree produced by TestFileParser#arguments. - def exitArguments(self, ctx:TestFileParser.ArgumentsContext): + def exitArguments(self, ctx: TestFileParser.ArgumentsContext): pass - # Enter a parse tree produced by TestFileParser#result. - def enterResult(self, ctx:TestFileParser.ResultContext): + def enterResult(self, ctx: TestFileParser.ResultContext): pass # Exit a parse tree produced by TestFileParser#result. - def exitResult(self, ctx:TestFileParser.ResultContext): + def exitResult(self, ctx: TestFileParser.ResultContext): pass - # Enter a parse tree produced by TestFileParser#argument. - def enterArgument(self, ctx:TestFileParser.ArgumentContext): + def enterArgument(self, ctx: TestFileParser.ArgumentContext): pass # Exit a parse tree produced by TestFileParser#argument. - def exitArgument(self, ctx:TestFileParser.ArgumentContext): + def exitArgument(self, ctx: TestFileParser.ArgumentContext): pass - # Enter a parse tree produced by TestFileParser#numericLiteral. - def enterNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + def enterNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): pass # Exit a parse tree produced by TestFileParser#numericLiteral. - def exitNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + def exitNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): pass - # Enter a parse tree produced by TestFileParser#nullArg. - def enterNullArg(self, ctx:TestFileParser.NullArgContext): + def enterNullArg(self, ctx: TestFileParser.NullArgContext): pass # Exit a parse tree produced by TestFileParser#nullArg. - def exitNullArg(self, ctx:TestFileParser.NullArgContext): + def exitNullArg(self, ctx: TestFileParser.NullArgContext): pass - # Enter a parse tree produced by TestFileParser#i8Arg. - def enterI8Arg(self, ctx:TestFileParser.I8ArgContext): + def enterI8Arg(self, ctx: TestFileParser.I8ArgContext): pass # Exit a parse tree produced by TestFileParser#i8Arg. - def exitI8Arg(self, ctx:TestFileParser.I8ArgContext): + def exitI8Arg(self, ctx: TestFileParser.I8ArgContext): pass - # Enter a parse tree produced by TestFileParser#i16Arg. - def enterI16Arg(self, ctx:TestFileParser.I16ArgContext): + def enterI16Arg(self, ctx: TestFileParser.I16ArgContext): pass # Exit a parse tree produced by TestFileParser#i16Arg. - def exitI16Arg(self, ctx:TestFileParser.I16ArgContext): + def exitI16Arg(self, ctx: TestFileParser.I16ArgContext): pass - # Enter a parse tree produced by TestFileParser#i32Arg. - def enterI32Arg(self, ctx:TestFileParser.I32ArgContext): + def enterI32Arg(self, ctx: TestFileParser.I32ArgContext): pass # Exit a parse tree produced by TestFileParser#i32Arg. - def exitI32Arg(self, ctx:TestFileParser.I32ArgContext): + def exitI32Arg(self, ctx: TestFileParser.I32ArgContext): pass - # Enter a parse tree produced by TestFileParser#i64Arg. - def enterI64Arg(self, ctx:TestFileParser.I64ArgContext): + def enterI64Arg(self, ctx: TestFileParser.I64ArgContext): pass # Exit a parse tree produced by TestFileParser#i64Arg. - def exitI64Arg(self, ctx:TestFileParser.I64ArgContext): + def exitI64Arg(self, ctx: TestFileParser.I64ArgContext): pass - # Enter a parse tree produced by TestFileParser#fp32Arg. - def enterFp32Arg(self, ctx:TestFileParser.Fp32ArgContext): + def enterFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): pass # Exit a parse tree produced by TestFileParser#fp32Arg. - def exitFp32Arg(self, ctx:TestFileParser.Fp32ArgContext): + def exitFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): pass - # Enter a parse tree produced by TestFileParser#fp64Arg. - def enterFp64Arg(self, ctx:TestFileParser.Fp64ArgContext): + def enterFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): pass # Exit a parse tree produced by TestFileParser#fp64Arg. - def exitFp64Arg(self, ctx:TestFileParser.Fp64ArgContext): + def exitFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): pass - # Enter a parse tree produced by TestFileParser#decimalArg. - def enterDecimalArg(self, ctx:TestFileParser.DecimalArgContext): + def enterDecimalArg(self, ctx: TestFileParser.DecimalArgContext): pass # Exit a parse tree produced by TestFileParser#decimalArg. - def exitDecimalArg(self, ctx:TestFileParser.DecimalArgContext): + def exitDecimalArg(self, ctx: TestFileParser.DecimalArgContext): pass - # Enter a parse tree produced by TestFileParser#booleanArg. - def enterBooleanArg(self, ctx:TestFileParser.BooleanArgContext): + def enterBooleanArg(self, ctx: TestFileParser.BooleanArgContext): pass # Exit a parse tree produced by TestFileParser#booleanArg. - def exitBooleanArg(self, ctx:TestFileParser.BooleanArgContext): + def exitBooleanArg(self, ctx: TestFileParser.BooleanArgContext): pass - # Enter a parse tree produced by TestFileParser#stringArg. - def enterStringArg(self, ctx:TestFileParser.StringArgContext): + def enterStringArg(self, ctx: TestFileParser.StringArgContext): pass # Exit a parse tree produced by TestFileParser#stringArg. - def exitStringArg(self, ctx:TestFileParser.StringArgContext): + def exitStringArg(self, ctx: TestFileParser.StringArgContext): pass - # Enter a parse tree produced by TestFileParser#dateArg. - def enterDateArg(self, ctx:TestFileParser.DateArgContext): + def enterDateArg(self, ctx: TestFileParser.DateArgContext): pass # Exit a parse tree produced by TestFileParser#dateArg. - def exitDateArg(self, ctx:TestFileParser.DateArgContext): + def exitDateArg(self, ctx: TestFileParser.DateArgContext): pass - # Enter a parse tree produced by TestFileParser#timeArg. - def enterTimeArg(self, ctx:TestFileParser.TimeArgContext): + def enterTimeArg(self, ctx: TestFileParser.TimeArgContext): pass # Exit a parse tree produced by TestFileParser#timeArg. - def exitTimeArg(self, ctx:TestFileParser.TimeArgContext): + def exitTimeArg(self, ctx: TestFileParser.TimeArgContext): pass - # Enter a parse tree produced by TestFileParser#timestampArg. - def enterTimestampArg(self, ctx:TestFileParser.TimestampArgContext): + def enterTimestampArg(self, ctx: TestFileParser.TimestampArgContext): pass # Exit a parse tree produced by TestFileParser#timestampArg. - def exitTimestampArg(self, ctx:TestFileParser.TimestampArgContext): + def exitTimestampArg(self, ctx: TestFileParser.TimestampArgContext): pass - # Enter a parse tree produced by TestFileParser#timestampTzArg. - def enterTimestampTzArg(self, ctx:TestFileParser.TimestampTzArgContext): + def enterTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): pass # Exit a parse tree produced by TestFileParser#timestampTzArg. - def exitTimestampTzArg(self, ctx:TestFileParser.TimestampTzArgContext): + def exitTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): pass - # Enter a parse tree produced by TestFileParser#intervalYearArg. - def enterIntervalYearArg(self, ctx:TestFileParser.IntervalYearArgContext): + def enterIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): pass # Exit a parse tree produced by TestFileParser#intervalYearArg. - def exitIntervalYearArg(self, ctx:TestFileParser.IntervalYearArgContext): + def exitIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): pass - # Enter a parse tree produced by TestFileParser#intervalDayArg. - def enterIntervalDayArg(self, ctx:TestFileParser.IntervalDayArgContext): + def enterIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): pass # Exit a parse tree produced by TestFileParser#intervalDayArg. - def exitIntervalDayArg(self, ctx:TestFileParser.IntervalDayArgContext): + def exitIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): pass - # Enter a parse tree produced by TestFileParser#intervalYearLiteral. - def enterIntervalYearLiteral(self, ctx:TestFileParser.IntervalYearLiteralContext): + def enterIntervalYearLiteral(self, ctx: TestFileParser.IntervalYearLiteralContext): pass # Exit a parse tree produced by TestFileParser#intervalYearLiteral. - def exitIntervalYearLiteral(self, ctx:TestFileParser.IntervalYearLiteralContext): + def exitIntervalYearLiteral(self, ctx: TestFileParser.IntervalYearLiteralContext): pass - # Enter a parse tree produced by TestFileParser#intervalDayLiteral. - def enterIntervalDayLiteral(self, ctx:TestFileParser.IntervalDayLiteralContext): + def enterIntervalDayLiteral(self, ctx: TestFileParser.IntervalDayLiteralContext): pass # Exit a parse tree produced by TestFileParser#intervalDayLiteral. - def exitIntervalDayLiteral(self, ctx:TestFileParser.IntervalDayLiteralContext): + def exitIntervalDayLiteral(self, ctx: TestFileParser.IntervalDayLiteralContext): pass - # Enter a parse tree produced by TestFileParser#timeInterval. - def enterTimeInterval(self, ctx:TestFileParser.TimeIntervalContext): + def enterTimeInterval(self, ctx: TestFileParser.TimeIntervalContext): pass # Exit a parse tree produced by TestFileParser#timeInterval. - def exitTimeInterval(self, ctx:TestFileParser.TimeIntervalContext): + def exitTimeInterval(self, ctx: TestFileParser.TimeIntervalContext): pass - # Enter a parse tree produced by TestFileParser#datatype. - def enterDatatype(self, ctx:TestFileParser.DatatypeContext): + def enterDatatype(self, ctx: TestFileParser.DatatypeContext): pass # Exit a parse tree produced by TestFileParser#datatype. - def exitDatatype(self, ctx:TestFileParser.DatatypeContext): + def exitDatatype(self, ctx: TestFileParser.DatatypeContext): pass - # Enter a parse tree produced by TestFileParser#Boolean. - def enterBoolean(self, ctx:TestFileParser.BooleanContext): + def enterBoolean(self, ctx: TestFileParser.BooleanContext): pass # Exit a parse tree produced by TestFileParser#Boolean. - def exitBoolean(self, ctx:TestFileParser.BooleanContext): + def exitBoolean(self, ctx: TestFileParser.BooleanContext): pass - # Enter a parse tree produced by TestFileParser#i8. - def enterI8(self, ctx:TestFileParser.I8Context): + def enterI8(self, ctx: TestFileParser.I8Context): pass # Exit a parse tree produced by TestFileParser#i8. - def exitI8(self, ctx:TestFileParser.I8Context): + def exitI8(self, ctx: TestFileParser.I8Context): pass - # Enter a parse tree produced by TestFileParser#i16. - def enterI16(self, ctx:TestFileParser.I16Context): + def enterI16(self, ctx: TestFileParser.I16Context): pass # Exit a parse tree produced by TestFileParser#i16. - def exitI16(self, ctx:TestFileParser.I16Context): + def exitI16(self, ctx: TestFileParser.I16Context): pass - # Enter a parse tree produced by TestFileParser#i32. - def enterI32(self, ctx:TestFileParser.I32Context): + def enterI32(self, ctx: TestFileParser.I32Context): pass # Exit a parse tree produced by TestFileParser#i32. - def exitI32(self, ctx:TestFileParser.I32Context): + def exitI32(self, ctx: TestFileParser.I32Context): pass - # Enter a parse tree produced by TestFileParser#i64. - def enterI64(self, ctx:TestFileParser.I64Context): + def enterI64(self, ctx: TestFileParser.I64Context): pass # Exit a parse tree produced by TestFileParser#i64. - def exitI64(self, ctx:TestFileParser.I64Context): + def exitI64(self, ctx: TestFileParser.I64Context): pass - # Enter a parse tree produced by TestFileParser#fp32. - def enterFp32(self, ctx:TestFileParser.Fp32Context): + def enterFp32(self, ctx: TestFileParser.Fp32Context): pass # Exit a parse tree produced by TestFileParser#fp32. - def exitFp32(self, ctx:TestFileParser.Fp32Context): + def exitFp32(self, ctx: TestFileParser.Fp32Context): pass - # Enter a parse tree produced by TestFileParser#fp64. - def enterFp64(self, ctx:TestFileParser.Fp64Context): + def enterFp64(self, ctx: TestFileParser.Fp64Context): pass # Exit a parse tree produced by TestFileParser#fp64. - def exitFp64(self, ctx:TestFileParser.Fp64Context): + def exitFp64(self, ctx: TestFileParser.Fp64Context): pass - # Enter a parse tree produced by TestFileParser#string. - def enterString(self, ctx:TestFileParser.StringContext): + def enterString(self, ctx: TestFileParser.StringContext): pass # Exit a parse tree produced by TestFileParser#string. - def exitString(self, ctx:TestFileParser.StringContext): + def exitString(self, ctx: TestFileParser.StringContext): pass - # Enter a parse tree produced by TestFileParser#binary. - def enterBinary(self, ctx:TestFileParser.BinaryContext): + def enterBinary(self, ctx: TestFileParser.BinaryContext): pass # Exit a parse tree produced by TestFileParser#binary. - def exitBinary(self, ctx:TestFileParser.BinaryContext): + def exitBinary(self, ctx: TestFileParser.BinaryContext): pass - # Enter a parse tree produced by TestFileParser#timestamp. - def enterTimestamp(self, ctx:TestFileParser.TimestampContext): + def enterTimestamp(self, ctx: TestFileParser.TimestampContext): pass # Exit a parse tree produced by TestFileParser#timestamp. - def exitTimestamp(self, ctx:TestFileParser.TimestampContext): + def exitTimestamp(self, ctx: TestFileParser.TimestampContext): pass - # Enter a parse tree produced by TestFileParser#timestampTz. - def enterTimestampTz(self, ctx:TestFileParser.TimestampTzContext): + def enterTimestampTz(self, ctx: TestFileParser.TimestampTzContext): pass # Exit a parse tree produced by TestFileParser#timestampTz. - def exitTimestampTz(self, ctx:TestFileParser.TimestampTzContext): + def exitTimestampTz(self, ctx: TestFileParser.TimestampTzContext): pass - # Enter a parse tree produced by TestFileParser#date. - def enterDate(self, ctx:TestFileParser.DateContext): + def enterDate(self, ctx: TestFileParser.DateContext): pass # Exit a parse tree produced by TestFileParser#date. - def exitDate(self, ctx:TestFileParser.DateContext): + def exitDate(self, ctx: TestFileParser.DateContext): pass - # Enter a parse tree produced by TestFileParser#time. - def enterTime(self, ctx:TestFileParser.TimeContext): + def enterTime(self, ctx: TestFileParser.TimeContext): pass # Exit a parse tree produced by TestFileParser#time. - def exitTime(self, ctx:TestFileParser.TimeContext): + def exitTime(self, ctx: TestFileParser.TimeContext): pass - # Enter a parse tree produced by TestFileParser#intervalDay. - def enterIntervalDay(self, ctx:TestFileParser.IntervalDayContext): + def enterIntervalDay(self, ctx: TestFileParser.IntervalDayContext): pass # Exit a parse tree produced by TestFileParser#intervalDay. - def exitIntervalDay(self, ctx:TestFileParser.IntervalDayContext): + def exitIntervalDay(self, ctx: TestFileParser.IntervalDayContext): pass - # Enter a parse tree produced by TestFileParser#intervalYear. - def enterIntervalYear(self, ctx:TestFileParser.IntervalYearContext): + def enterIntervalYear(self, ctx: TestFileParser.IntervalYearContext): pass # Exit a parse tree produced by TestFileParser#intervalYear. - def exitIntervalYear(self, ctx:TestFileParser.IntervalYearContext): + def exitIntervalYear(self, ctx: TestFileParser.IntervalYearContext): pass - # Enter a parse tree produced by TestFileParser#uuid. - def enterUuid(self, ctx:TestFileParser.UuidContext): + def enterUuid(self, ctx: TestFileParser.UuidContext): pass # Exit a parse tree produced by TestFileParser#uuid. - def exitUuid(self, ctx:TestFileParser.UuidContext): + def exitUuid(self, ctx: TestFileParser.UuidContext): pass - # Enter a parse tree produced by TestFileParser#userDefined. - def enterUserDefined(self, ctx:TestFileParser.UserDefinedContext): + def enterUserDefined(self, ctx: TestFileParser.UserDefinedContext): pass # Exit a parse tree produced by TestFileParser#userDefined. - def exitUserDefined(self, ctx:TestFileParser.UserDefinedContext): + def exitUserDefined(self, ctx: TestFileParser.UserDefinedContext): pass - # Enter a parse tree produced by TestFileParser#fixedChar. - def enterFixedChar(self, ctx:TestFileParser.FixedCharContext): + def enterFixedChar(self, ctx: TestFileParser.FixedCharContext): pass # Exit a parse tree produced by TestFileParser#fixedChar. - def exitFixedChar(self, ctx:TestFileParser.FixedCharContext): + def exitFixedChar(self, ctx: TestFileParser.FixedCharContext): pass - # Enter a parse tree produced by TestFileParser#varChar. - def enterVarChar(self, ctx:TestFileParser.VarCharContext): + def enterVarChar(self, ctx: TestFileParser.VarCharContext): pass # Exit a parse tree produced by TestFileParser#varChar. - def exitVarChar(self, ctx:TestFileParser.VarCharContext): + def exitVarChar(self, ctx: TestFileParser.VarCharContext): pass - # Enter a parse tree produced by TestFileParser#fixedBinary. - def enterFixedBinary(self, ctx:TestFileParser.FixedBinaryContext): + def enterFixedBinary(self, ctx: TestFileParser.FixedBinaryContext): pass # Exit a parse tree produced by TestFileParser#fixedBinary. - def exitFixedBinary(self, ctx:TestFileParser.FixedBinaryContext): + def exitFixedBinary(self, ctx: TestFileParser.FixedBinaryContext): pass - # Enter a parse tree produced by TestFileParser#decimal. - def enterDecimal(self, ctx:TestFileParser.DecimalContext): + def enterDecimal(self, ctx: TestFileParser.DecimalContext): pass # Exit a parse tree produced by TestFileParser#decimal. - def exitDecimal(self, ctx:TestFileParser.DecimalContext): + def exitDecimal(self, ctx: TestFileParser.DecimalContext): pass - # Enter a parse tree produced by TestFileParser#precisionTimestamp. - def enterPrecisionTimestamp(self, ctx:TestFileParser.PrecisionTimestampContext): + def enterPrecisionTimestamp(self, ctx: TestFileParser.PrecisionTimestampContext): pass # Exit a parse tree produced by TestFileParser#precisionTimestamp. - def exitPrecisionTimestamp(self, ctx:TestFileParser.PrecisionTimestampContext): + def exitPrecisionTimestamp(self, ctx: TestFileParser.PrecisionTimestampContext): pass - # Enter a parse tree produced by TestFileParser#precisionTimestampTZ. - def enterPrecisionTimestampTZ(self, ctx:TestFileParser.PrecisionTimestampTZContext): + def enterPrecisionTimestampTZ( + self, ctx: TestFileParser.PrecisionTimestampTZContext + ): pass # Exit a parse tree produced by TestFileParser#precisionTimestampTZ. - def exitPrecisionTimestampTZ(self, ctx:TestFileParser.PrecisionTimestampTZContext): + def exitPrecisionTimestampTZ(self, ctx: TestFileParser.PrecisionTimestampTZContext): pass - # Enter a parse tree produced by TestFileParser#parameterizedType. - def enterParameterizedType(self, ctx:TestFileParser.ParameterizedTypeContext): + def enterParameterizedType(self, ctx: TestFileParser.ParameterizedTypeContext): pass # Exit a parse tree produced by TestFileParser#parameterizedType. - def exitParameterizedType(self, ctx:TestFileParser.ParameterizedTypeContext): + def exitParameterizedType(self, ctx: TestFileParser.ParameterizedTypeContext): pass - # Enter a parse tree produced by TestFileParser#integerLiteral. - def enterIntegerLiteral(self, ctx:TestFileParser.IntegerLiteralContext): + def enterIntegerLiteral(self, ctx: TestFileParser.IntegerLiteralContext): pass # Exit a parse tree produced by TestFileParser#integerLiteral. - def exitIntegerLiteral(self, ctx:TestFileParser.IntegerLiteralContext): + def exitIntegerLiteral(self, ctx: TestFileParser.IntegerLiteralContext): pass - # Enter a parse tree produced by TestFileParser#substraitError. - def enterSubstraitError(self, ctx:TestFileParser.SubstraitErrorContext): + def enterSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): pass # Exit a parse tree produced by TestFileParser#substraitError. - def exitSubstraitError(self, ctx:TestFileParser.SubstraitErrorContext): + def exitSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): pass - # Enter a parse tree produced by TestFileParser#func_option. - def enterFunc_option(self, ctx:TestFileParser.Func_optionContext): + def enterFunc_option(self, ctx: TestFileParser.Func_optionContext): pass # Exit a parse tree produced by TestFileParser#func_option. - def exitFunc_option(self, ctx:TestFileParser.Func_optionContext): + def exitFunc_option(self, ctx: TestFileParser.Func_optionContext): pass - # Enter a parse tree produced by TestFileParser#option_name. - def enterOption_name(self, ctx:TestFileParser.Option_nameContext): + def enterOption_name(self, ctx: TestFileParser.Option_nameContext): pass # Exit a parse tree produced by TestFileParser#option_name. - def exitOption_name(self, ctx:TestFileParser.Option_nameContext): + def exitOption_name(self, ctx: TestFileParser.Option_nameContext): pass - # Enter a parse tree produced by TestFileParser#option_value. - def enterOption_value(self, ctx:TestFileParser.Option_valueContext): + def enterOption_value(self, ctx: TestFileParser.Option_valueContext): pass # Exit a parse tree produced by TestFileParser#option_value. - def exitOption_value(self, ctx:TestFileParser.Option_valueContext): + def exitOption_value(self, ctx: TestFileParser.Option_valueContext): pass - # Enter a parse tree produced by TestFileParser#func_options. - def enterFunc_options(self, ctx:TestFileParser.Func_optionsContext): + def enterFunc_options(self, ctx: TestFileParser.Func_optionsContext): pass # Exit a parse tree produced by TestFileParser#func_options. - def exitFunc_options(self, ctx:TestFileParser.Func_optionsContext): + def exitFunc_options(self, ctx: TestFileParser.Func_optionsContext): pass - -del TestFileParser \ No newline at end of file +del TestFileParser diff --git a/tests/coverage/antlr_parser/TestFileParserVisitor.py b/tests/coverage/antlr_parser/TestFileParserVisitor.py index 5c7e86f79..bed7eac21 100644 --- a/tests/coverage/antlr_parser/TestFileParserVisitor.py +++ b/tests/coverage/antlr_parser/TestFileParserVisitor.py @@ -1,5 +1,6 @@ # Generated from TestFileParser.g4 by ANTLR 4.13.2 from antlr4 import * + if "." in __name__: from .TestFileParser import TestFileParser else: @@ -7,312 +8,256 @@ # This class defines a complete generic visitor for a parse tree produced by TestFileParser. + class TestFileParserVisitor(ParseTreeVisitor): # Visit a parse tree produced by TestFileParser#doc. - def visitDoc(self, ctx:TestFileParser.DocContext): + def visitDoc(self, ctx: TestFileParser.DocContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#header. - def visitHeader(self, ctx:TestFileParser.HeaderContext): + def visitHeader(self, ctx: TestFileParser.HeaderContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#version. - def visitVersion(self, ctx:TestFileParser.VersionContext): + def visitVersion(self, ctx: TestFileParser.VersionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#include. - def visitInclude(self, ctx:TestFileParser.IncludeContext): + def visitInclude(self, ctx: TestFileParser.IncludeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#testGroupDescription. - def visitTestGroupDescription(self, ctx:TestFileParser.TestGroupDescriptionContext): + def visitTestGroupDescription( + self, ctx: TestFileParser.TestGroupDescriptionContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#testCase. - def visitTestCase(self, ctx:TestFileParser.TestCaseContext): + def visitTestCase(self, ctx: TestFileParser.TestCaseContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#testGroup. - def visitTestGroup(self, ctx:TestFileParser.TestGroupContext): + def visitTestGroup(self, ctx: TestFileParser.TestGroupContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#arguments. - def visitArguments(self, ctx:TestFileParser.ArgumentsContext): + def visitArguments(self, ctx: TestFileParser.ArgumentsContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#result. - def visitResult(self, ctx:TestFileParser.ResultContext): + def visitResult(self, ctx: TestFileParser.ResultContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#argument. - def visitArgument(self, ctx:TestFileParser.ArgumentContext): + def visitArgument(self, ctx: TestFileParser.ArgumentContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#numericLiteral. - def visitNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + def visitNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#nullArg. - def visitNullArg(self, ctx:TestFileParser.NullArgContext): + def visitNullArg(self, ctx: TestFileParser.NullArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i8Arg. - def visitI8Arg(self, ctx:TestFileParser.I8ArgContext): + def visitI8Arg(self, ctx: TestFileParser.I8ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i16Arg. - def visitI16Arg(self, ctx:TestFileParser.I16ArgContext): + def visitI16Arg(self, ctx: TestFileParser.I16ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i32Arg. - def visitI32Arg(self, ctx:TestFileParser.I32ArgContext): + def visitI32Arg(self, ctx: TestFileParser.I32ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i64Arg. - def visitI64Arg(self, ctx:TestFileParser.I64ArgContext): + def visitI64Arg(self, ctx: TestFileParser.I64ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#fp32Arg. - def visitFp32Arg(self, ctx:TestFileParser.Fp32ArgContext): + def visitFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#fp64Arg. - def visitFp64Arg(self, ctx:TestFileParser.Fp64ArgContext): + def visitFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#decimalArg. - def visitDecimalArg(self, ctx:TestFileParser.DecimalArgContext): + def visitDecimalArg(self, ctx: TestFileParser.DecimalArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#booleanArg. - def visitBooleanArg(self, ctx:TestFileParser.BooleanArgContext): + def visitBooleanArg(self, ctx: TestFileParser.BooleanArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#stringArg. - def visitStringArg(self, ctx:TestFileParser.StringArgContext): + def visitStringArg(self, ctx: TestFileParser.StringArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#dateArg. - def visitDateArg(self, ctx:TestFileParser.DateArgContext): + def visitDateArg(self, ctx: TestFileParser.DateArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#timeArg. - def visitTimeArg(self, ctx:TestFileParser.TimeArgContext): + def visitTimeArg(self, ctx: TestFileParser.TimeArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#timestampArg. - def visitTimestampArg(self, ctx:TestFileParser.TimestampArgContext): + def visitTimestampArg(self, ctx: TestFileParser.TimestampArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#timestampTzArg. - def visitTimestampTzArg(self, ctx:TestFileParser.TimestampTzArgContext): + def visitTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#intervalYearArg. - def visitIntervalYearArg(self, ctx:TestFileParser.IntervalYearArgContext): + def visitIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#intervalDayArg. - def visitIntervalDayArg(self, ctx:TestFileParser.IntervalDayArgContext): + def visitIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#intervalYearLiteral. - def visitIntervalYearLiteral(self, ctx:TestFileParser.IntervalYearLiteralContext): + def visitIntervalYearLiteral(self, ctx: TestFileParser.IntervalYearLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#intervalDayLiteral. - def visitIntervalDayLiteral(self, ctx:TestFileParser.IntervalDayLiteralContext): + def visitIntervalDayLiteral(self, ctx: TestFileParser.IntervalDayLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#timeInterval. - def visitTimeInterval(self, ctx:TestFileParser.TimeIntervalContext): + def visitTimeInterval(self, ctx: TestFileParser.TimeIntervalContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#datatype. - def visitDatatype(self, ctx:TestFileParser.DatatypeContext): + def visitDatatype(self, ctx: TestFileParser.DatatypeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#Boolean. - def visitBoolean(self, ctx:TestFileParser.BooleanContext): + def visitBoolean(self, ctx: TestFileParser.BooleanContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i8. - def visitI8(self, ctx:TestFileParser.I8Context): + def visitI8(self, ctx: TestFileParser.I8Context): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i16. - def visitI16(self, ctx:TestFileParser.I16Context): + def visitI16(self, ctx: TestFileParser.I16Context): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i32. - def visitI32(self, ctx:TestFileParser.I32Context): + def visitI32(self, ctx: TestFileParser.I32Context): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#i64. - def visitI64(self, ctx:TestFileParser.I64Context): + def visitI64(self, ctx: TestFileParser.I64Context): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#fp32. - def visitFp32(self, ctx:TestFileParser.Fp32Context): + def visitFp32(self, ctx: TestFileParser.Fp32Context): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#fp64. - def visitFp64(self, ctx:TestFileParser.Fp64Context): + def visitFp64(self, ctx: TestFileParser.Fp64Context): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#string. - def visitString(self, ctx:TestFileParser.StringContext): + def visitString(self, ctx: TestFileParser.StringContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#binary. - def visitBinary(self, ctx:TestFileParser.BinaryContext): + def visitBinary(self, ctx: TestFileParser.BinaryContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#timestamp. - def visitTimestamp(self, ctx:TestFileParser.TimestampContext): + def visitTimestamp(self, ctx: TestFileParser.TimestampContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#timestampTz. - def visitTimestampTz(self, ctx:TestFileParser.TimestampTzContext): + def visitTimestampTz(self, ctx: TestFileParser.TimestampTzContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#date. - def visitDate(self, ctx:TestFileParser.DateContext): + def visitDate(self, ctx: TestFileParser.DateContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#time. - def visitTime(self, ctx:TestFileParser.TimeContext): + def visitTime(self, ctx: TestFileParser.TimeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#intervalDay. - def visitIntervalDay(self, ctx:TestFileParser.IntervalDayContext): + def visitIntervalDay(self, ctx: TestFileParser.IntervalDayContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#intervalYear. - def visitIntervalYear(self, ctx:TestFileParser.IntervalYearContext): + def visitIntervalYear(self, ctx: TestFileParser.IntervalYearContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#uuid. - def visitUuid(self, ctx:TestFileParser.UuidContext): + def visitUuid(self, ctx: TestFileParser.UuidContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#userDefined. - def visitUserDefined(self, ctx:TestFileParser.UserDefinedContext): + def visitUserDefined(self, ctx: TestFileParser.UserDefinedContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#fixedChar. - def visitFixedChar(self, ctx:TestFileParser.FixedCharContext): + def visitFixedChar(self, ctx: TestFileParser.FixedCharContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#varChar. - def visitVarChar(self, ctx:TestFileParser.VarCharContext): + def visitVarChar(self, ctx: TestFileParser.VarCharContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#fixedBinary. - def visitFixedBinary(self, ctx:TestFileParser.FixedBinaryContext): + def visitFixedBinary(self, ctx: TestFileParser.FixedBinaryContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#decimal. - def visitDecimal(self, ctx:TestFileParser.DecimalContext): + def visitDecimal(self, ctx: TestFileParser.DecimalContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#precisionTimestamp. - def visitPrecisionTimestamp(self, ctx:TestFileParser.PrecisionTimestampContext): + def visitPrecisionTimestamp(self, ctx: TestFileParser.PrecisionTimestampContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#precisionTimestampTZ. - def visitPrecisionTimestampTZ(self, ctx:TestFileParser.PrecisionTimestampTZContext): + def visitPrecisionTimestampTZ( + self, ctx: TestFileParser.PrecisionTimestampTZContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#parameterizedType. - def visitParameterizedType(self, ctx:TestFileParser.ParameterizedTypeContext): + def visitParameterizedType(self, ctx: TestFileParser.ParameterizedTypeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#integerLiteral. - def visitIntegerLiteral(self, ctx:TestFileParser.IntegerLiteralContext): + def visitIntegerLiteral(self, ctx: TestFileParser.IntegerLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#substraitError. - def visitSubstraitError(self, ctx:TestFileParser.SubstraitErrorContext): + def visitSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#func_option. - def visitFunc_option(self, ctx:TestFileParser.Func_optionContext): + def visitFunc_option(self, ctx: TestFileParser.Func_optionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#option_name. - def visitOption_name(self, ctx:TestFileParser.Option_nameContext): + def visitOption_name(self, ctx: TestFileParser.Option_nameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#option_value. - def visitOption_value(self, ctx:TestFileParser.Option_valueContext): + def visitOption_value(self, ctx: TestFileParser.Option_valueContext): return self.visitChildren(ctx) - # Visit a parse tree produced by TestFileParser#func_options. - def visitFunc_options(self, ctx:TestFileParser.Func_optionsContext): + def visitFunc_options(self, ctx: TestFileParser.Func_optionsContext): return self.visitChildren(ctx) - -del TestFileParser \ No newline at end of file +del TestFileParser diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index b6056961f..8c38a3b6c 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -59,33 +59,43 @@ def dump_coverage(self): total_variants = 0 for file_coverage in self.file_coverage.values(): for function_coverage in file_coverage.function_coverage.values(): - for sig, test_count in function_coverage.function_variant_coverage.items(): + for ( + sig, + test_count, + ) in function_coverage.function_variant_coverage.items(): total_variants += 1 if test_count > 0: covered_variants += 1 print(f"{file_coverage.file_name} \t\t{sig}: {test_count}") - print(f"Total test count: {self.test_count}, {covered_variants}/{total_variants} function variants are covered") + print( + f"Total test count: {self.test_count}, {covered_variants}/{total_variants} function variants are covered" + ) def update_test_count(test_case_files: list, function_registry: FunctionRegistry): for test_file in test_case_files: for test_case in test_file.testcases: - function_variant = function_registry.get_function(test_case.func_name, test_case.get_arg_types()) + function_variant = function_registry.get_function( + test_case.func_name, test_case.get_arg_types() + ) if function_variant: - if function_variant.return_type != test_case.get_return_type() and not test_case.is_return_type_error(): - error(f"Return type mismatch in function {test_case.func_name}: {function_variant.return_type} != {test_case.get_return_type()}") + if ( + function_variant.return_type != test_case.get_return_type() + and not test_case.is_return_type_error() + ): + error( + f"Return type mismatch in function {test_case.func_name}: {function_variant.return_type} != {test_case.get_return_type()}" + ) continue function_variant.increment_test_count() else: error(f"Function not found: {test_case.func_name}({test_case.args})") - if __name__ == "__main__": - test_files = load_all_testcases('../cases') + test_files = load_all_testcases("../cases") function_registry = Extension.read_substrait_extensions("../../extensions") coverage = TestCoverage(function_registry.get_extension_list()) update_test_count(test_files, function_registry) function_registry.fill_coverage(coverage) coverage.dump_coverage() - diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index 675090e78..8449eee5f 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -15,51 +15,49 @@ def debug(msg): type_to_short_type = { - 'required enumeration': 'req', - 'i8': 'i8', - 'i16': 'i16', - 'i32': 'i32', - 'i64': 'i64', - 'fp32': 'fp32', - 'fp64': 'fp64', - 'string': 'str', - 'binary': 'vbin', - 'boolean': 'bool', - 'timestamp': 'ts', - 'timestamp_tz': 'tstz', - 'date': 'date', - 'time': 'time', - 'interval_year': 'iyear', - 'interval_day': 'iday', - 'uuid': 'uuid', - 'fixedchar': 'fchar', - 'varchar': 'vchar', - 'fixedbinary': 'fbin', - 'decimal': 'dec', - 'precision_timestamp

': 'pts', - 'precision_timestamp_tz

': 'ptstz', - 'struct': 'struct', - 'list': 'list', - 'map': 'map', - 'map': 'map', - 'any': 'any', - 'any1': 'any1', - 'any2': 'any2', - 'any3': 'any3', - 'user defined type': 'u!name', - + "required enumeration": "req", + "i8": "i8", + "i16": "i16", + "i32": "i32", + "i64": "i64", + "fp32": "fp32", + "fp64": "fp64", + "string": "str", + "binary": "vbin", + "boolean": "bool", + "timestamp": "ts", + "timestamp_tz": "tstz", + "date": "date", + "time": "time", + "interval_year": "iyear", + "interval_day": "iday", + "uuid": "uuid", + "fixedchar": "fchar", + "varchar": "vchar", + "fixedbinary": "fbin", + "decimal": "dec", + "precision_timestamp

": "pts", + "precision_timestamp_tz

": "ptstz", + "struct": "struct", + "list": "list", + "map": "map", + "map": "map", + "any": "any", + "any1": "any1", + "any2": "any2", + "any3": "any3", + "user defined type": "u!name", # added to handle parametrized types - 'fixedchar': 'fchar', - 'varchar': 'vchar', - 'fixedbinary': 'fbin', - 'decimal': 'dec', - 'precision_timestamp': 'pts', - 'precision_timestamp_tz': 'ptstz', - 'struct': 'struct', - 'list': 'list', - + "fixedchar": "fchar", + "varchar": "vchar", + "fixedbinary": "fbin", + "decimal": "dec", + "precision_timestamp": "pts", + "precision_timestamp_tz": "ptstz", + "struct": "struct", + "list": "list", # added to handle geometry type - 'geometry': 'geometry', + "geometry": "geometry", } short_type_to_type = {st: lt for lt, st in type_to_short_type.items()} @@ -68,31 +66,31 @@ def debug(msg): class Extension: @staticmethod def get_base_uri(): - return 'https://github.com/substrait-io/substrait/blob/main/extensions/' + return "https://github.com/substrait-io/substrait/blob/main/extensions/" @staticmethod def get_short_type(long_type): - long_type = long_type.lower().rstrip('?') + long_type = long_type.lower().rstrip("?") short_type = type_to_short_type.get(long_type, None) if short_type is None: # remove the type parameters and try again - if '<' in long_type: - long_type = long_type[:long_type.find('<')].rstrip('?') + if "<" in long_type: + long_type = long_type[: long_type.find("<")].rstrip("?") short_type = type_to_short_type.get(long_type, None) if short_type is None: - if '\n' in long_type: - long_type = long_type.split('\n')[-1] + if "\n" in long_type: + long_type = long_type.split("\n")[-1] short_type = type_to_short_type.get(long_type, None) if short_type is None: - if '!' not in long_type: + if "!" not in long_type: error(f"Type not found in the mapping: {long_type}") return long_type return short_type @staticmethod def get_long_type(short_type): - if short_type.endswith('?'): + if short_type.endswith("?"): short_type = short_type[:-1] long_type = short_type_to_type.get(short_type, None) if long_type is None: @@ -103,36 +101,46 @@ def get_long_type(short_type): @staticmethod def get_supported_kernels_from_impls(func): overloads = [] - for impl in func['impls']: + for impl in func["impls"]: args = [] - if 'args' in impl: - for arg in impl['args']: - if 'value' in arg: - arg_type = arg['value'] - if arg_type.endswith('?'): + if "args" in impl: + for arg in impl["args"]: + if "value" in arg: + arg_type = arg["value"] + if arg_type.endswith("?"): arg_type = arg_type[:-1] args.append(Extension.get_short_type(arg_type)) else: - debug(f"arg is not a value type for function: {func['name']} arg must be enum options {arg['options']}") - args.append('str') - overloads.append(FunctionOverload(args, Extension.get_short_type(impl['return']), 'variadic' in impl)) + debug( + f"arg is not a value type for function: {func['name']} arg must be enum options {arg['options']}" + ) + args.append("str") + overloads.append( + FunctionOverload( + args, Extension.get_short_type(impl["return"]), "variadic" in impl + ) + ) return overloads @staticmethod def add_functions_to_map(func_list, function_map, suffix, extension): dup_idx = 0 for func in func_list: - name = func['name'] + name = func["name"] uri = extension[5:] # strip the ../.. if name in function_map: - debug(f"Duplicate function name: {name} renaming to {name}_{suffix} extension: {extension}") + debug( + f"Duplicate function name: {name} renaming to {name}_{suffix} extension: {extension}" + ) dup_idx += 1 name = f"{name}_dup{dup_idx}_{suffix}" - assert name not in function_map, f"Duplicate function name: {name} renaming to {name}_{suffix} extension: {extension}" - func['overloads'] = Extension.get_supported_kernels_from_impls(func) - func['uri'] = uri - func.pop('description', None) - func.pop('impls', None) + assert ( + name not in function_map + ), f"Duplicate function name: {name} renaming to {name}_{suffix} extension: {extension}" + func["overloads"] = Extension.get_supported_kernels_from_impls(func) + func["uri"] = uri + func.pop("description", None) + func.pop("impls", None) function_map[name] = func @staticmethod @@ -141,7 +149,7 @@ def read_substrait_extensions(dir_path: str): extensions = [] for root, dirs, files in os.walk(dir_path): for file in files: - if file.endswith('.yaml') and file.startswith('functions_'): + if file.endswith(".yaml") and file.startswith("functions_"): extensions.append(os.path.join(root, file)) extensions.sort() @@ -153,20 +161,33 @@ def read_substrait_extensions(dir_path: str): # convert yaml file to a python dictionary for extension in extensions: suffix = extension[:-5] # strip .yaml at the end of the extension - suffix = suffix[suffix.rfind('/') + 1:] # strip the path and get the name of the extension - suffix = suffix[suffix.find('_') + 1:] # get the suffix after the last _ + suffix = suffix[ + suffix.rfind("/") + 1 : + ] # strip the path and get the name of the extension + suffix = suffix[suffix.find("_") + 1 :] # get the suffix after the last _ dependencies[suffix] = Extension.get_base_uri() + extension - with open(extension, 'r') as fh: + with open(extension, "r") as fh: data = yaml.load(fh, Loader=yaml.FullLoader) - if 'scalar_functions' in data: - Extension.add_functions_to_map(data['scalar_functions'], scalar_functions, suffix, extension) - if 'aggregate_functions' in data: - Extension.add_functions_to_map(data['aggregate_functions'], aggregate_functions, suffix, extension) - if 'window_functions' in data: - Extension.add_functions_to_map(data['window_functions'], scalar_functions, suffix, extension) - - return FunctionRegistry(scalar_functions, aggregate_functions, window_functions, dependencies) + if "scalar_functions" in data: + Extension.add_functions_to_map( + data["scalar_functions"], scalar_functions, suffix, extension + ) + if "aggregate_functions" in data: + Extension.add_functions_to_map( + data["aggregate_functions"], + aggregate_functions, + suffix, + extension, + ) + if "window_functions" in data: + Extension.add_functions_to_map( + data["window_functions"], scalar_functions, suffix, extension + ) + + return FunctionRegistry( + scalar_functions, aggregate_functions, window_functions, dependencies + ) class FunctionType: @@ -202,6 +223,7 @@ def __init__(self, args, return_type, variadic): def __str__(self): return f"FunctionOverload(args={self.args}, result={self.return_type}, variadic={self.variadic})" + # define function type enum @@ -213,7 +235,9 @@ class FunctionRegistry: window_functions = dict() extensions = set() - def __init__(self, scalar_functions, aggregate_functions, window_functions, dependencies): + def __init__( + self, scalar_functions, aggregate_functions, window_functions, dependencies + ): self.dependencies = dependencies self.scalar_functions = scalar_functions self.aggregate_functions = aggregate_functions @@ -224,11 +248,19 @@ def __init__(self, scalar_functions, aggregate_functions, window_functions, depe def add_functions(self, functions, func_type): for func in functions.values(): - self.extensions.add(func['uri']) + self.extensions.add(func["uri"]) f_name = func["name"] fun_arr = self.registry.get(f_name, []) for overload in func["overloads"]: - function = FunctionVariant(func["name"], func["uri"], "", overload.args, overload.return_type, overload.variadic, func_type) + function = FunctionVariant( + func["name"], + func["uri"], + "", + overload.args, + overload.return_type, + overload.variadic, + func_type, + ) fun_arr.append(function) self.registry[f_name] = fun_arr @@ -246,5 +278,6 @@ def get_extension_list(self): def fill_coverage(self, coverage): for func_name, functions in self.registry.items(): for function in functions: - coverage.update_coverage(function.uri, func_name, function.args, function.test_count) - + coverage.update_coverage( + function.uri, func_name, function.args, function.test_count + ) diff --git a/tests/coverage/nodes.py b/tests/coverage/nodes.py index 5dc7ec09e..fb5dfa5a8 100644 --- a/tests/coverage/nodes.py +++ b/tests/coverage/nodes.py @@ -12,6 +12,7 @@ class CaseGroup: class SubstraitError: error: str + @dataclass class CaseLiteral: value: str | int | float | list @@ -19,9 +20,9 @@ class CaseLiteral: def get_base_type(self): type = self.type - if '<' in type: - type = type[:type.find('<')] - if type.endswith('?'): + if "<" in type: + type = type[: type.find("<")] + if type.endswith("?"): return type[:-1] return type diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py index 1f1eec1f7..13df9c80d 100644 --- a/tests/coverage/test_coverage.py +++ b/tests/coverage/test_coverage.py @@ -36,10 +36,12 @@ def test_parse_date_time_example(): assert test_file.testcases[0].func_name == "lt" assert test_file.testcases[0].base_uri == "/extensions/functions_datetime.yaml" assert test_file.testcases[0].group.name == "timestamps" - assert test_file.testcases[0].group.description == "examples using the timestamp type" - assert test_file.testcases[0].result == CaseLiteral('true', "bool") - assert test_file.testcases[0].args[0] == CaseLiteral('2016-12-31T13:30:15', "ts") - assert test_file.testcases[0].args[1] == CaseLiteral('2017-12-31T13:30:15', "ts") + assert ( + test_file.testcases[0].group.description == "examples using the timestamp type" + ) + assert test_file.testcases[0].result == CaseLiteral("true", "bool") + assert test_file.testcases[0].args[0] == CaseLiteral("2016-12-31T13:30:15", "ts") + assert test_file.testcases[0].args[1] == CaseLiteral("2017-12-31T13:30:15", "ts") def test_parse_decimal_example(): @@ -54,12 +56,18 @@ def test_parse_decimal_example(): ) assert len(test_file.testcases) == 2 assert test_file.testcases[0].func_name == "power" - assert test_file.testcases[0].base_uri == "extensions/functions_arithmetic_decimal.yaml" + assert ( + test_file.testcases[0].base_uri + == "extensions/functions_arithmetic_decimal.yaml" + ) assert test_file.testcases[0].group.name == "basic" - assert test_file.testcases[0].group.description == "Basic examples without any special cases" - assert test_file.testcases[0].result == CaseLiteral('64', "fp64") - assert test_file.testcases[0].args[0] == CaseLiteral('8', "dec<38,0>") - assert test_file.testcases[0].args[1] == CaseLiteral('2', "dec<38,0>") + assert ( + test_file.testcases[0].group.description + == "Basic examples without any special cases" + ) + assert test_file.testcases[0].result == CaseLiteral("64", "fp64") + assert test_file.testcases[0].args[0] == CaseLiteral("8", "dec<38,0>") + assert test_file.testcases[0].args[1] == CaseLiteral("2", "dec<38,0>") def test_parse_file(): @@ -77,4 +85,7 @@ def test_parse_file(): test_file = parse_one_file("../cases/arithmetic_decimal/power.test") assert len(test_file.testcases) == 9 assert test_file.testcases[0].func_name == "power" - assert test_file.testcases[0].base_uri == "extensions/functions_arithmetic_decimal.yaml" + assert ( + test_file.testcases[0].base_uri + == "extensions/functions_arithmetic_decimal.yaml" + ) diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index 5bb9fc3e3..6087e9f6a 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -1,7 +1,13 @@ # SPDX-License-Identifier: Apache-2.0 from tests.coverage.antlr_parser.TestFileParser import TestFileParser from tests.coverage.antlr_parser.TestFileParserVisitor import TestFileParserVisitor -from tests.coverage.nodes import CaseGroup, TestFile, TestCase, CaseLiteral, SubstraitError +from tests.coverage.nodes import ( + CaseGroup, + TestFile, + TestCase, + CaseLiteral, + SubstraitError, +) class TestCaseVisitor(TestFileParserVisitor): @@ -31,7 +37,9 @@ def visitInclude(self, ctx: TestFileParser.IncludeContext): # TODO handle multiple includes return ctx.STRING_LITERAL(0).getText().strip("'") - def visitTestGroupDescription(self, ctx: TestFileParser.TestGroupDescriptionContext): + def visitTestGroupDescription( + self, ctx: TestFileParser.TestGroupDescriptionContext + ): group = ctx.DESCRIPTION_LINE().getText().strip("#").strip() parts = group.split(":") if len(parts) == 2: @@ -55,13 +63,15 @@ def visitTestCase(self, ctx: TestFileParser.TestCaseContext): options = dict() if ctx.func_options() is not None: options = self.visitFunc_options(ctx.func_options()) - return TestCase(func_name=ctx.IDENTIFIER().getText(), - base_uri="", - group=None, - options=options, - args=args, - result=result, - comment="") + return TestCase( + func_name=ctx.IDENTIFIER().getText(), + base_uri="", + group=None, + options=options, + args=args, + result=result, + comment="", + ) def visitFunc_options(self, ctx: TestFileParser.Func_optionsContext): options = {} @@ -117,7 +127,7 @@ def visitArgument(self, ctx: TestFileParser.ArgumentContext): return CaseLiteral(value="unknown_value", type="unknown_type") - def visitNumericLiteral(self, ctx:TestFileParser.NumericLiteralContext): + def visitNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): if ctx.INTEGER_LITERAL() is not None: return ctx.INTEGER_LITERAL().getText() if ctx.DECIMAL_LITERAL() is not None: @@ -142,10 +152,16 @@ def visitI64Arg(self, ctx: TestFileParser.I64ArgContext): def visitFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): # TODO add checks on number of decimal places - return CaseLiteral(value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.FP32().getText().lower()) + return CaseLiteral( + value=self.visitNumericLiteral(ctx.numericLiteral()), + type=ctx.FP32().getText().lower(), + ) def visitFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): - return CaseLiteral(value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.FP64().getText().lower()) + return CaseLiteral( + value=self.visitNumericLiteral(ctx.numericLiteral()), + type=ctx.FP64().getText().lower(), + ) def visitBooleanArg(self, ctx: TestFileParser.BooleanArgContext): return CaseLiteral(value=ctx.BOOLEAN_LITERAL().getText(), type="bool") @@ -154,7 +170,10 @@ def visitStringArg(self, ctx: TestFileParser.StringArgContext): return CaseLiteral(value=ctx.STRING_LITERAL().getText(), type="str") def visitDecimalArg(self, ctx: TestFileParser.DecimalArgContext): - return CaseLiteral(value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.decimalType().getText().lower()) + return CaseLiteral( + value=self.visitNumericLiteral(ctx.numericLiteral()), + type=ctx.decimalType().getText().lower(), + ) def visitDateArg(self, ctx: TestFileParser.DateArgContext): return CaseLiteral(value=ctx.DATE_LITERAL().getText().strip("'"), type="date") @@ -163,16 +182,24 @@ def visitTimeArg(self, ctx: TestFileParser.TimeArgContext): return CaseLiteral(value=ctx.TIME_LITERAL().getText().strip("'"), type="time") def visitTimestampArg(self, ctx: TestFileParser.TimestampArgContext): - return CaseLiteral(value=ctx.TIMESTAMP_LITERAL().getText().strip("'"), type="ts") + return CaseLiteral( + value=ctx.TIMESTAMP_LITERAL().getText().strip("'"), type="ts" + ) def visitTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): - return CaseLiteral(value=ctx.TIMESTAMP_TZ_LITERAL().getText().strip("'"), type="tstz") + return CaseLiteral( + value=ctx.TIMESTAMP_TZ_LITERAL().getText().strip("'"), type="tstz" + ) def visitIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): - return CaseLiteral(value=ctx.INTERVAL_DAY_LITERAL().getText().strip("'"), type="iday") + return CaseLiteral( + value=ctx.INTERVAL_DAY_LITERAL().getText().strip("'"), type="iday" + ) def visitIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): - return CaseLiteral(value=ctx.INTERVAL_YEAR_LITERAL().getText().strip("'"), type="iyear") + return CaseLiteral( + value=ctx.INTERVAL_YEAR_LITERAL().getText().strip("'"), type="iyear" + ) def visitResult(self, ctx: TestFileParser.ResultContext): if ctx.argument() is not None: diff --git a/tests/test_extensions.py b/tests/test_extensions.py index d63778ba7..0f97dd01b 100644 --- a/tests/test_extensions.py +++ b/tests/test_extensions.py @@ -1,6 +1,7 @@ def test_read_substrait_extensions(): from tests.coverage.extensions import Extension - registry = Extension.read_substrait_extensions('../extensions') + + registry = Extension.read_substrait_extensions("../extensions") assert len(registry.function_registry) >= 143 num_overloads = sum([len(f) for f in registry.function_registry.values()]) assert num_overloads >= 425 From 6478c3448c47964aaf74ae2f6c436c20ec98f02d Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Tue, 3 Sep 2024 19:37:13 +0530 Subject: [PATCH 09/19] Fix python style-check 2 --- tests/coverage/antlr_parser/TestFileParser.py | 24 ------------------- 1 file changed, 24 deletions(-) diff --git a/tests/coverage/antlr_parser/TestFileParser.py b/tests/coverage/antlr_parser/TestFileParser.py index 8d19f2d16..dde66b703 100644 --- a/tests/coverage/antlr_parser/TestFileParser.py +++ b/tests/coverage/antlr_parser/TestFileParser.py @@ -5955,7 +5955,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class DateContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -5980,7 +5979,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class StringContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6005,7 +6003,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I64Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6030,7 +6027,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class UserDefinedContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6058,7 +6054,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I32Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6083,7 +6078,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class IntervalYearContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6108,7 +6102,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class UuidContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6133,7 +6126,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I8Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6158,7 +6150,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I16Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6183,7 +6174,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class BinaryContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6208,7 +6198,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class IntervalDayContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6233,7 +6222,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class Fp64Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6258,7 +6246,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class Fp32Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6283,7 +6270,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class TimeContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6308,7 +6294,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class BooleanContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6333,7 +6318,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class TimestampContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6358,7 +6342,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class TimestampTzContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.ScalarTypeContext @@ -6521,7 +6504,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class FixedCharContext(FixedCharTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.FixedCharTypeContext @@ -6606,7 +6588,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class VarCharContext(VarCharTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.VarCharTypeContext @@ -6691,7 +6672,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class FixedBinaryContext(FixedBinaryTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.FixedBinaryTypeContext @@ -6776,7 +6756,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class DecimalContext(DecimalTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.DecimalTypeContext @@ -6879,7 +6858,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class PrecisionTimestampContext(PrecisionTimestampTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.PrecisionTimestampTypeContext @@ -6966,7 +6944,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class PrecisionTimestampTZContext(PrecisionTimestampTZTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.PrecisionTimestampTZTypeContext @@ -7150,7 +7127,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class IntegerLiteralContext(NumericParameterContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a TestFileParser.NumericParameterContext From d783159856e99d09eee4cdcf471f99de6ebaeaef Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Tue, 3 Sep 2024 19:51:45 +0530 Subject: [PATCH 10/19] Fix python style-check 3 --- tests/coverage/antlr_parser/SubstraitLexer.py | 9 +++++++-- tests/coverage/antlr_parser/TestFileLexer.py | 9 +++++++-- tests/coverage/antlr_parser/TestFileParser.py | 16 ++++++++++++++-- .../antlr_parser/TestFileParserListener.py | 2 +- .../antlr_parser/TestFileParserVisitor.py | 2 +- tests/coverage/coverage.py | 2 +- 6 files changed, 31 insertions(+), 9 deletions(-) diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py index 2c53bd400..7f10c05c3 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.py +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -1,6 +1,11 @@ # Generated from SubstraitLexer.g4 by ANTLR 4.13.2 -from antlr4 import * -from io import StringIO +from antlr4 import ( + ATNDeserializer, + DFA, + Lexer, + LexerATNSimulator, + PredictionContextCache, +) import sys if sys.version_info[1] > 5: diff --git a/tests/coverage/antlr_parser/TestFileLexer.py b/tests/coverage/antlr_parser/TestFileLexer.py index d510327cd..d157d5cc7 100644 --- a/tests/coverage/antlr_parser/TestFileLexer.py +++ b/tests/coverage/antlr_parser/TestFileLexer.py @@ -1,6 +1,11 @@ # Generated from TestFileLexer.g4 by ANTLR 4.13.2 -from antlr4 import * -from io import StringIO +from antlr4 import ( + ATNDeserializer, + DFA, + Lexer, + LexerATNSimulator, + PredictionContextCache, +) import sys if sys.version_info[1] > 5: diff --git a/tests/coverage/antlr_parser/TestFileParser.py b/tests/coverage/antlr_parser/TestFileParser.py index dde66b703..fc888d538 100644 --- a/tests/coverage/antlr_parser/TestFileParser.py +++ b/tests/coverage/antlr_parser/TestFileParser.py @@ -1,7 +1,19 @@ # Generated from TestFileParser.g4 by ANTLR 4.13.2 # encoding: utf-8 -from antlr4 import * -from io import StringIO +from antlr4 import ( + ATNDeserializer, + DFA, + NoViableAltException, + ParseTreeListener, + ParseTreeVisitor, + Parser, + ParserATNSimulator, + ParserRuleContext, + PredictionContextCache, + RecognitionException, + Token, + TokenStream, +) import sys if sys.version_info[1] > 5: diff --git a/tests/coverage/antlr_parser/TestFileParserListener.py b/tests/coverage/antlr_parser/TestFileParserListener.py index 62b384dce..c8a13e795 100644 --- a/tests/coverage/antlr_parser/TestFileParserListener.py +++ b/tests/coverage/antlr_parser/TestFileParserListener.py @@ -1,5 +1,5 @@ # Generated from TestFileParser.g4 by ANTLR 4.13.2 -from antlr4 import * +from antlr4 import ParseTreeListener if "." in __name__: from .TestFileParser import TestFileParser diff --git a/tests/coverage/antlr_parser/TestFileParserVisitor.py b/tests/coverage/antlr_parser/TestFileParserVisitor.py index bed7eac21..85edafe1f 100644 --- a/tests/coverage/antlr_parser/TestFileParserVisitor.py +++ b/tests/coverage/antlr_parser/TestFileParserVisitor.py @@ -1,5 +1,5 @@ # Generated from TestFileParser.g4 by ANTLR 4.13.2 -from antlr4 import * +from antlr4 import ParseTreeVisitor if "." in __name__: from .TestFileParser import TestFileParser diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index 8c38a3b6c..6d8f40379 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -31,7 +31,7 @@ def __init__(self, file_name): self.function_coverage = dict() def update_coverage(self, func_name, args, count): - key = f"{func_name}({", ".join(args)})" + key = f"{func_name}({', '.join(args)})" if func_name not in self.function_coverage: self.function_coverage[func_name] = FunctionTestCoverage(func_name) self.function_coverage[func_name].update_coverage(key, count) From 283bfd2df8ba763a9145e26b0292f5f36309c7e1 Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Tue, 3 Sep 2024 20:14:02 +0530 Subject: [PATCH 11/19] Fix python style-check 4 --- tests/coverage/antlr_parser/SubstraitLexer.py | 1 + tests/coverage/antlr_parser/TestFileLexer.py | 1 + tests/coverage/antlr_parser/TestFileParser.py | 1 + tests/coverage/antlr_parser/TestFileParserListener.py | 1 + tests/coverage/antlr_parser/TestFileParserVisitor.py | 1 + tests/coverage/case_file_parser.py | 1 + tests/coverage/extensions.py | 1 + tests/coverage/nodes.py | 1 + tests/coverage/test_coverage.py | 1 + tests/test_extensions.py | 1 + 10 files changed, 10 insertions(+) diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py index 7f10c05c3..081a1e211 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.py +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from SubstraitLexer.g4 by ANTLR 4.13.2 from antlr4 import ( ATNDeserializer, diff --git a/tests/coverage/antlr_parser/TestFileLexer.py b/tests/coverage/antlr_parser/TestFileLexer.py index d157d5cc7..ddd82704b 100644 --- a/tests/coverage/antlr_parser/TestFileLexer.py +++ b/tests/coverage/antlr_parser/TestFileLexer.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from TestFileLexer.g4 by ANTLR 4.13.2 from antlr4 import ( ATNDeserializer, diff --git a/tests/coverage/antlr_parser/TestFileParser.py b/tests/coverage/antlr_parser/TestFileParser.py index fc888d538..d14a36e23 100644 --- a/tests/coverage/antlr_parser/TestFileParser.py +++ b/tests/coverage/antlr_parser/TestFileParser.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from TestFileParser.g4 by ANTLR 4.13.2 # encoding: utf-8 from antlr4 import ( diff --git a/tests/coverage/antlr_parser/TestFileParserListener.py b/tests/coverage/antlr_parser/TestFileParserListener.py index c8a13e795..68f946545 100644 --- a/tests/coverage/antlr_parser/TestFileParserListener.py +++ b/tests/coverage/antlr_parser/TestFileParserListener.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from TestFileParser.g4 by ANTLR 4.13.2 from antlr4 import ParseTreeListener diff --git a/tests/coverage/antlr_parser/TestFileParserVisitor.py b/tests/coverage/antlr_parser/TestFileParserVisitor.py index 85edafe1f..2a4c74dc2 100644 --- a/tests/coverage/antlr_parser/TestFileParserVisitor.py +++ b/tests/coverage/antlr_parser/TestFileParserVisitor.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from TestFileParser.g4 by ANTLR 4.13.2 from antlr4 import ParseTreeVisitor diff --git a/tests/coverage/case_file_parser.py b/tests/coverage/case_file_parser.py index 132a7ca04..d49c9bacb 100644 --- a/tests/coverage/case_file_parser.py +++ b/tests/coverage/case_file_parser.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 import os from antlr4 import CommonTokenStream, FileStream diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index 8449eee5f..e599132a9 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 import os import yaml from ruamel.yaml import YAML diff --git a/tests/coverage/nodes.py b/tests/coverage/nodes.py index fb5dfa5a8..cfafe5296 100644 --- a/tests/coverage/nodes.py +++ b/tests/coverage/nodes.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 from dataclasses import dataclass from typing import List diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py index 13df9c80d..8e0ce2fce 100644 --- a/tests/coverage/test_coverage.py +++ b/tests/coverage/test_coverage.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 from antlr4 import InputStream from tests.coverage.case_file_parser import parse_stream, parse_one_file from tests.coverage.nodes import CaseLiteral diff --git a/tests/test_extensions.py b/tests/test_extensions.py index 0f97dd01b..0facf7395 100644 --- a/tests/test_extensions.py +++ b/tests/test_extensions.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 def test_read_substrait_extensions(): from tests.coverage.extensions import Extension From 1830e6331f199260b9b3ebb04be3d4d22b83ca1d Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Tue, 3 Sep 2024 20:17:57 +0530 Subject: [PATCH 12/19] Get rid of unused file --- grammar/TypeDerivation.g4 | 612 -------------------------------------- 1 file changed, 612 deletions(-) delete mode 100644 grammar/TypeDerivation.g4 diff --git a/grammar/TypeDerivation.g4 b/grammar/TypeDerivation.g4 deleted file mode 100644 index a90e988d0..000000000 --- a/grammar/TypeDerivation.g4 +++ /dev/null @@ -1,612 +0,0 @@ -grammar TypeDerivation; - -// Note: this grammar is intentionally written to avoid ANTLR-specific features -// that someone who hasn't used ANTLR before might not know about, including -// explicitly avoiding left recursion, such that it can easily be ported to -// other parser generators if necessary. In this way, it hopefully doubles as a -// human-readable specification for this DSL. -// -// This comes at the cost of not generating very nice parse trees. You can use -// this grammar with ANTLR directly if you want, but you might want to rewrite -// it if you intend to use the listener or generated AST directly. -// -// Some things that you will need to know if you've never seen ANTLR before: -// - ANTLR distinguishes between tokenizer rules and parser rules by -// capitalization of the rule name: if the first letter is uppercase, the -// rule is a token rule; if it is lowercase, it is a parser rule. Yuck. -// - When multiple token rules match: -// - choose the token that matches the most text; -// - if same length, use the one defined earlier. -// (ANTLR supports implicit tokens as well, but we don't use them) -// - Parse conflicts are solved using PEG rules. That is, for alternations, -// the first alternative that matches the input is used. For ?, *, and +, -// matching is greedy. -// - The ~ symbol is used to negate character sets, as opposed to the [^...] -// syntax from regular expressions. - - -//============================================================================= -// Whitespace and comment tokens -//============================================================================= - -// Whitespace and comment handling. You can use C-style line and block -// comments. -LineComment : '//' ~[\r\n]* -> channel(HIDDEN) ; -BlockComment : ( '/*' ( ~'*' | '*'+ ~[*/] ) '*'* '*/' ) -> channel(HIDDEN) ; -Whitespace : [ \t]+ -> channel(HIDDEN) ; - -// Type derivations are newline-sensitive, so they're not ignored. -Newline : [\r\n]+ ; - -// Newlines can be embedded by escaping the newline character itself with a -// backslash. -EscNewline : '\\' [\r\n]+ -> channel(HIDDEN) ; - - -//============================================================================= -// Keyword tokens -//============================================================================= - -// Substrait is case-insensitive, ANTLR is not. So, in order to define our -// keywords in a somewhat readable way, we have to define these shortcuts. -// If you've never seen ANTLR before, fragment rules are pretty much just -// glorified preprocessor/search-and-replace macros. -fragment A : [aA]; fragment B : [bB]; fragment C : [cC]; fragment D : [dD]; -fragment E : [eE]; fragment F : [fF]; fragment G : [gG]; fragment H : [hH]; -fragment I : [iI]; fragment J : [jJ]; fragment K : [kK]; fragment L : [lL]; -fragment M : [mM]; fragment N : [nN]; fragment O : [oO]; fragment P : [pP]; -fragment Q : [qQ]; fragment R : [rR]; fragment S : [sS]; fragment T : [tT]; -fragment U : [uU]; fragment V : [vV]; fragment W : [wW]; fragment X : [xX]; -fragment Y : [yY]; fragment Z : [zZ]; - -// Syntactic keywords. -Assert : A S S E R T ; -Matches : M A T C H E S ; -If : I F ; -Then : T H E N ; -Else : E L S E ; - -// Named literal values. -Null : N U L L ; -True : T R U E ; -False : F A L S E ; - -// Metatype identification keywords. -Metabool : M E T A B O O L ; -Metaint : M E T A I N T ; -Metaenum : M E T A E N U M ; -Metastr : M E T A S T R ; -Typename : T Y P E N A M E ; - -// Note that data type classes are not keywords. We support user-defined type -// classes anyway, so name resolution has to be done after parsing anyway. - - -//============================================================================= -// Symbol tokens -//============================================================================= - -// Symbols used. -Period : '.' ; // identifier paths -Comma : ',' ; // separator for pattern lists -Colon : ':' ; // separator for named parameters -Semicolon : ';' ; // separator for statements -Question : '?' ; // any, inconsistent bindings & nullable type suffix -Bang : '!' ; // boolean NOT & explicitly non-nullable type suffix -OpenParen : '(' ; // precedence override & function call args (open) -CloseParen : ')' ; // precedence override & function call args (close) -OpenCurly : '{' ; // enum set patterns (open) -CloseCurly : '}' ; // enum set patterns (close) -OpenSquare : '[' ; // data type variation suffix (open) -CloseSquare : ']' ; // data type variation suffix (close) -Assign : '=' ; // assignment statements -BooleanOr : '||' ; // boolean OR expression -BooleanAnd : '&&' ; // boolean AND expression -Equal : '==' ; // equality expression -NotEqual : '!=' ; // not-equals expression -LessThan : '<' ; // less-than expression & data type parameter pack -LessEqual : '<=' ; // less-equal expression -GreaterThan : '>' ; // greater-than expression & data type parameter pack -GreaterEqual : '>=' ; // greater-equal expression -Plus : '+' ; // additions and integer literal sign -Minus : '-' ; // subtractions, negation, and integer literal sign -Multiply : '*' ; // multiplication expression -Divide : '/' ; // division expression -Range : '..' ; // integer set patterns - - -//============================================================================= -// Procedurally-matched tokens -//============================================================================= - -// Tokens for integer literals. -Nonzero : [1-9] [0-9]* ; -Zero : '0' ; - -// String literal token. -String : '"' ~["] '"' ; - -// Identifier token. Note that $ signs are legal in identifiers, and note that -// all identifier matching is case-insensitive. Note also that keywords take -// precedence. -Identifier : [a-zA-Z_$] [a-zA-Z0-9_$]* ; - - -//============================================================================= -// Grammar rules -//============================================================================= - -// Most things in the simple extension YAMLs that refer to a type are parsed -// using patterns; patterns can both matched and evaluated (not ALL patterns -// can do both, but there is considerable overlap between the two classes, -// so they were conceptually merged). When a type needs to be derived based on -// a number of given metavalues, such as the data types of arguments passed to -// a function, a derivation program is used. Syntactically, the only difference -// is that programs can include a set of statements before the final pattern. -// Newlines can optionally go before or after a type derivation pattern or -// program without affecting syntax. -startPattern : Whitespace* Newline* pattern Newline* EOF ; -startProgram : Whitespace* Newline* program Newline* EOF ; - -// A type derivation program consists of zero or more statements followed by -// the final pattern that should evaluate to the derived data type. -program : ( statement statementSeparator )* pattern ; - -// Statements are separated from each other and from the final derivation -// expression using newlines or a semicolon. -statementSeparator : Newline* ( Newline | Semicolon Newline* ) ; - -// Statements manipulate the state of the type derivation interpreter before -// the final derivation expression is evaluated. They look like assignment -// statements at first glance, but act more like equality or set containment -// assertions: the right-hand side is evaluated like an expression as you -// might expect, but the left-hand side acts just like the patterns that are -// used to match function argument types. While this is perhaps not the most -// intuitive ruleset, it is extremely easy to implement (it only reuses -// features we already needed anyway), while also being a much more powerful -// primitive than a simple assignment statement, because it can also be used -// for bounds checking and other assertions. For example, if we have a -// function like `fn(VARCHAR(a), VARCHAR(b))` and the implementation of the -// function requires that a + b equals 10, we can simply write "10 = a + b". -// This works, because the pattern "10" will only match the value 10, and -// a pattern mismatch at any point during the matching and evaluation process -// indicates that the implementation is incompatible with the given argument -// types. If you find this syntax confusing, you may also write -// "assert a + b matches 10" or "assert a + b == 10"; the former does the -// exact same thing, while the latter reduces to "true = a + b == 10", which is -// functionally the same thing. -// -// Note that when you use these statements like assignment statements, you can -// only ever reassign a binding to the same value. For example, "a = 10; a = 20" -// will always fail, because a cannot both be 10 and 20 at the same time (more -// accurately, a is bound to 10, so the second statement behaves like -// "10 = 20", and 20 does not match 10). -statement - : pattern Assign pattern #Normal - | Assert pattern Matches pattern #Match - | Assert pattern #Assert - ; - -// Patterns are at the core of the type derivation interpreter; they are used -// both for matching and as expressions. However, note that not all types of -// patterns work in both contexts. -pattern : patternInvalidIfThenElse ; - -patternInvalidIfThenElse - : patternOr #ValidPattern - - // The following rule is ILLEGAL and only exists for better error recovery - // in the validator. It's an incomplete implementation of a C-style - // if-then-else, which should be written as "if x then y else z" instead. - // The reason is that this rule makes question marks HEAVILY ambiguous. - // ANTLR can sort of deal with this because it implements a PEG parser - // and will thus attempt the above option first, but many parser frameworks - // won't handle this correctly, and parsing will be slow. Hence the - // non-standard syntax. The validator supports this nonetheless because some - // core extensions are using C-style if-then-else at the time of writing, and - // the documentation is rather ambiguous about which it should be. - | patternOr Question patternOr Colon pattern #InvalidIfThenElse - ; - -// Lazily-evaluated boolean OR expression. Maps to builtin or() function if -// more than one pattern is parsed. -patternOr : patternAnd ( operatorOr patternAnd )* ; -operatorOr : BooleanOr #Or ; - -// Lazily-evaluated boolean AND expression. Maps to builtin and() function if -// more than one pattern is parsed. -patternAnd : patternEqNeq ( operatorAnd patternEqNeq )* ; -operatorAnd : BooleanAnd #And ; - -// Equality and not-equality expressions. These map to the builtin equal() -// and not_equal() functions in left-to-right order. -patternEqNeq : patternIneq ( operatorEqNeq patternIneq )* ; -operatorEqNeq : Equal #Eq | NotEqual #Neq ; - -// Integer inequality expressions. These map to the builtin greater_than(), -// less_than(), greater_equal(), and less_equal() functions in left-to-right -// order. -patternIneq : patternAddSub ( operatorIneq patternAddSub )* ; -operatorIneq : LessThan #Lt | LessEqual #Le | GreaterThan #Gt | GreaterEqual #Ge ; - -// Integer addition and subtraction. These map to the builtin add() and -// subtract() functions in left-to-right order. -patternAddSub : patternMulDiv ( operatorAddSub patternMulDiv )* ; -operatorAddSub : Plus #Add | Minus #Sub ; - -// Integer multiplication and division. These map to the builtin multiply() and -// divide() functions in left-to-right order. -patternMulDiv : patternMisc ( operatorMulDiv patternMisc )* ; -operatorMulDiv : Multiply #Mul | Divide #Div ; - -// Miscellaneous patterns that don't need special rules for precedence or -// avoiding left-recursion. -patternMisc - - // Parentheses for overriding operator precedence. - : OpenParen pattern CloseParen #parentheses - - // If-then-else pattern. Can only be evaluated. The first pattern must - // evaluate to a boolean. The second or third pattern is then evaluated - // based on that boolean and returned. The branch that is not selected is - // also not evaluated (i.e. evaluation is lazy). - | If pattern Then pattern Else pattern #ifThenElse - - // Unary not function. Can only be evaluated and can only be applied to - // booleans. - | Bang pattern #unaryNot - - // The "anything" pattern. This matches everything, and cannot be evaluated. - // It's primarily intended for matching (parts of) argument types, when you - // don't need or want a binding. For example, `equals(?, ?) -> boolean` would - // allow for any combination of argument types. This distinguishes it from - // `equals(any1, any1) -> boolean`, which only accepts equal types; instead - // it behaves like `equals(any1, any2) -> boolean`. `?` is especially useful - // when you want this type of behavior for a variadic function; for example, - // `serialize(?...) -> binary` will match any number and combination of - // argument types, while `serialize(any1...) -> binary` would only accept any - // number of any *one* data type. - | Question #any - - // Matches any boolean value. Cannot be evaluated. - | Metabool #boolAny - - // Matches and evaluates to the boolean value "true". - | True #boolTrue - - // Matches and evaluates to the boolean value "false". - | False #boolFalse - - // Matches any integer value. Cannot be evaluated. - | Metaint #intAny - - // Matches any integer value within the specified inclusive range. Can only - // be evaluated if the two bounds are equal, in which case it reduces to just - // a single integer. - | integer Range integer #intRange - - // Matches any integer value that equals at least the given number. Cannot be - // evaluated. - | integer Range #intAtLeast - - // Matches any integer value that equals at most the given number. Cannot be - // evaluated. - | Range integer #intAtMost - - // Matches and evaluates to exactly the given integer. - | integer #intExactly - - // Matches any enumeration constant. - | Metaenum #enumAny - - // Matches an enumeration constant in the given set. If only a single - // constant is specified, the pattern evaluates to that constant, otherwise - // it cannot be evaluated. - | OpenCurly Identifier (Comma Identifier)* CloseCurly #enumSet - - // Matches any string. - | Metastr #strAny - - // Matches and evaluates to exactly the given string. - | String #strExactly - - // Matches any typename for which the nullability matches the nullability - // suffix. Use `typename??` for either nullability. - | Typename nullability? #dtAny - - // Evaluates a function. When a function is used in match context, the - // function (and its arguments) will be *evaluated* instead, and the incoming - // value is matched against the result. This means that it is legal to define - // a function like f(VARCHAR(x), VARCHAR(y), VARCHAR(x + y)) because the x - // and y bindings are captured before x + y is evaluated, but it is NOT legal - // to define it like f(VARCHAR(x + y), VARCHAR(x), VARCHAR(y)) because x and - // y are not yet bound when x + y is evaluated. - // f(VARCHAR(x), VARCHAR(x + y), VARCHAR(y)) is also NOT legal, again because - // some of the function bindings have not yet been captured, even though - // mathematically this could be rewritten from x + y <- input to - // y <= input - x (the evaluator is not smart enough for this, and this - // rewriting cannot be generalized over all functions). - // - // The following functions are currently available: - // - // - "not(metabool) -> metabool": boolean NOT. - // - "and(metabool*) -> metabool": boolean AND. Evaluated lazily from left - // to right. - // - "or(metabool*) -> metabool": boolean OR. Evaluated lazily from left to - // right. - // - "negate(metaint) -> metaint": integer negation. 64-bit two's complement - // overflow must be detected, and implies that the function implementation - // that the program belongs to does not match the given argument types. - // - "add(metaint*) -> metaint": integer sum. Overflow handled as above. - // - "subtract(metaint, metaint) -> metaint": subtracts an integer from - // another. Overflow handled as above. - // - "multiply(metaint*) -> metaint": integer product. Overflow handled as - // above. - // - "divide(metaint, metaint) -> metaint": divides an integer over - // another. Overflow and division by zero handled as above. - // - "min(metaint+) -> metaint": return the minimum integer value. - // - "max(metaint+) -> metaint": return the maximum integer value. - // - "equal(T, T) -> metabool": return whether the two values are equal. - // - "not_equal(T, T) -> metabool": return whether the two values are not - // equal. - // - "greater_than(metaint, metaint) -> metabool": return whether the left - // integer is greater than the right. - // - "less_than(metaint, metaint) -> metabool": return whether the left - // integer is less than the right. - // - "greater_equal(metaint, metaint) -> metabool": return whether the left - // integer is greater than or equal to the right. - // - "less_equal(metaint, metaint) -> metabool": return whether the left - // integer is less than or equal to the right. - // - "covers(value, pattern) -> metabool": return whether the left value - // matches the pattern. The pattern may make use of bindings that were - // previously defined. New bindings are captured if and only if covers - // returns true. This allows for patterns like - // assert if covers(x, struct) then a < 10 \ - // else if covers(x, struct) then a + b < 10 \ - // else false; - // to be written and work as expected. - // - "if_then_else(metabool, T, T) -> T": if-then-else expression. Evaluated - // lazily. - // - // Note that many of the functions also have corresponding expressions. These - // expressions are simply syntactic sugar for calling the functions directly. - | Identifier OpenParen ( pattern (Comma pattern)* )? CloseParen #function - - // This pattern matches one of three things, which are too context-sensitive - // to distinguish at this time: - // - // - a data type pattern; - // - an enum constant; - // - a normal binding; or - // - a binding with nullability override. - // - // The type depends on the identifier path, and must be disambiguated as - // follows during name resolution: - // - // - Keep track of a case-insensitive mapping from name to binding, enum - // constant, or type class while analyzing the parse tree. It will be - // empty initially. - // - Whenever this pattern appears, resolve the name using this mapping: - // - If resolution fails, resolve the name as a type class instead (it - // could be the name of a builtin type class, a type class defined - // in the current extension, or a type class defined in a dependency - // if appropriately prefixed with the dependency namespace): - // - If this succeeds, add an entry to the name mapping, mapping the - // incoming identifier path to the type class. If the type class is - // user-defined, and the type class has enum parameter slots, also - // add entries to the name mapping for all the enum variants; if a - // name was already defined, do NOT update the mapping. Finally, - // disambiguate the pattern as a data type pattern. - // - If this fails and the identifier path consists of only a single - // element, map the incoming identifier path to a binding, and - // disambiguate the pattern as a normal binding or a binding - // with nullability override, depending on the presence of the - // nullability field. - // - If the above fails and the identifier path consists of multiple - // elements, analysis should fail. - // - If resolution yields a binding, disambiguate the pattern as a - // normal binding or a binding with nullability override, depending on - // the presence of the nullability field. - // - If resolution yields an enum constant, disambiguate the pattern as - // an enum constant. - // - If resolution yields a type class, disambiguate the pattern as a - // data type pattern. - // - // If the optional nullability, variation, or parameters fields are non-empty - // when they can't be according to the rules of the disambiguated pattern - // type, analysis should fail. - // - // Note that the `!` suffix disambiguates between a normal binding and a - // binding with a non-nullable nullability override. For a data type pattern, - // non-nullable is the default, so something like `i32` is exactly the same - // as `i32!`. - // - // The behavior for the resolved pattern types is: - // - Data type pattern: - // - Matches a metavalue if and only if: - // - the metavalue is a typename; - // - the type class matches the identified class; - // - the nullability of the type matches the rules detailed in the - // comments of the nullability rule; - // - the variation of the type matches the rules detailed in the - // comments of the variation rule; and - // - the parameter pack matches the rules detailed in the comments - // of the parameters rule. - // - Evaluates to a data type with the specified type class and the - // evaluation result of the nullability, variation, and parameters - // fields. If any of those things cannot be evaluated, the data type - // pattern cannot be evaluated. If any parameter pack constraint - // violations result from this, they are treated as pattern match - // failures (i.e., if this happens in a return type derivation of - // a function, the function is said to not match the given arguments). - // - // - Enum constant: - // - Matches a metavalue if and only if it is exactly the specified enum - // variant. - // - Evaluates to the specified enum variant. - // - The nullability, variation, and parameters fields are illegal and - // must be blank. - // - // - Consistent binding without nullability suffix: - // - If this is the first use of the name, matches non-typename - // metavalues and non-nullable typenames. The incoming metavalue is - // bound to the name as a side effect. - // - If the name was previously bound, matches only if the incoming - // metavalue is exactly equal to the previous binding. - // - Can only be evaluated if the name was previously bound, in which - // case it yields the bound value exactly. - // - The variation and parameter pack fields are illegal and must be - // blank. - // - // - Consistent binding with nullability suffix: - // - If this is the first use of the name, matches if and only if: - // - the incoming metavalue is a typename; and - // - the nullability of the incoming type matches the nullability - // suffix. - // If the above rules match, the incoming typename, with its - // nullability overridden to non-nullable, is bound to the name as a - // side effect. - // - If the name was previously bound, matches if and only if: - // - the incoming metavalue is a typename; - // - the nullability of the incoming type matches the nullability - // suffix; - // - the previously bound metavalue is a typename; and - // - the incoming type matches the previously bound type, ignoring - // nullability and parameter names. - // - Can only be evaluated if the name was previously bound. If the - // previously bound metavalue is not a typename, evaluation fails. The - // returned type is the previously bound type, with its nullability - // adjusted according to the nullability suffix evaluation rules. - // - The variation and parameters fields are illegal and must be blank. - | identifierPath nullability? variation? parameters? #datatypeBindingOrConstant - - // Pattern for inconsistent bindings. Inconsistent bindings are variations - // of normal bindings and bindings with nullability override with looser - // matching and extended evaluation rules. These rules are designed - // specifically for matching inconsistent variadic arguments and for - // modelling MIRROR nullability behavior. Specifically: - // - // - Use `?T` instead of `T` for a variadic argument slot to capture the - // value of the first argument and ignore the rest, thus rendering it - // inconsistent. - // - Use `type??nullable` instead of `type` for argument slots and the - // return type to match both nullable and non-nullable data types for - // the argument, and yield a nullable return type only if any of the - // bound arguments are nullable. - // - // The exacty behavior for the pattern types is as follows. Rules that differ - // from the consistent binding rules are highlighted with (!). - // - // - Inconsistent binding without nullability suffix: - // - If this is the first use of the name, matches non-typename - // metavalues and non-nullable typenames. The incoming metavalue is - // bound to the name as a side effect. - // - (!) If the name was previously bound, still matches all - // non-typename metavalues and non-nullable typenames. If the - // incoming metavalue is boolean `true`, and the currently bound - // metavalue is boolean `false`, rebind the name to `true` as a side - // effect. Otherwise, leave it unchanged. - // - (!) If this is the first use of the name, evaluation yields - // the metabool `false` (for the nullability of the return type in - // a MIRROR function). - // - If the name was previously bound, evaluation yields the bound - // value exactly. - // - // - Inconsistent binding with nullability override: - // - If this is the first use of the name, matches if and only if: - // - the incoming metavalue is a typename; and - // - the nullability of the incoming type matches the nullability - // field. - // If the above rules match, the incoming typename, with its - // nullability overridden to non-nullable, is bound to the name as a - // side effect. - // - (!) If the binding was previously bound, matches if and only if: - // - the incoming metavalue is a typename; and - // - the nullability of the incoming type matches the nullability - // field. - // There are no side effects in this case. - // - Can only be evaluated if the name was previously bound. If the - // previously bound metavalue is not a typename, evaluation fails. The - // returned type is the previously bound type, with its nullability - // adjusted according to the nullability field evaluation rules. - | Question Identifier nullability? #inconsistent - - // Unary negation function. Can only be evaluated and can only be applied to - // integers. Note that this is all the way at the back because signed integer - // literals should be preferred, since those can also be matched, and can - // deal with -2^63 without overflow. - | Minus pattern #unaryNegate - ; - -// Nullability suffix. -// -// - If there is no such suffix, or the suffix is "!", the pattern matches -// only non-nullable types, and also evaluates to a non-nullable type if -// applicable. The "!" suffix changes the semantics of bindings slightly -// compared to no suffix (specifically, `x!` only matches non-nullable -// typenames, but `x` also matches non-typename metavalues), but is -// otherwise optional and customarily not written. -// - If this suffix is just "?", the pattern matches only nullable types, -// and also evaluates to a nullable type if applicable. -// - If this suffix is a "?" followed by a pattern, the pattern is matched -// against false for non-nullable and true for nullable types. Likewise for -// evaluation; if the pattern evaluates to false the type will be -// non-nullable, if it evaluates to true it will be nullable. -nullability - : Bang #nonNullable - | Question #nullable - | Question pattern #nullableIf - ; - -// Type variation suffix. -// -// - If there is no such suffix, the pattern matches any variation that is -// marked as compatible with the system-preferred variation via the function -// behavior option of the variation, as well as the system-preferred -// variation itself. It will evaluate to the system-preferred variation. -// - If the suffix is [?], the pattern matches any variation, and cannot be -// evaluated. -// - If the suffix is [0], the pattern matches and evaluates to the -// system-preferred variation exactly. -// - If the suffix is [ident], the pattern matches and evaluates to the named -// variation exactly. The variation must be in scope. -variation : OpenSquare variationBody CloseSquare ; -variationBody - : Question #varAny - | Zero #varSystemPreferred - | identifierPath #varUserDefined - ; - -// Type parameter pack suffix. -// -// - If there is no such suffix, the pattern accepts any number of parameters -// for the type (assuming that the type class accepts this as well), and -// will attempt to evaluate to a type with no parameters. -// - If there is a "<>" suffix, the pattern accepts only types with zero -// parameters, and will attempt to evaluate to a type with no parameters. -// - If parameters are specified, the pattern accepts only types with exactly -// the specified number of parameters, and will attempt to evaluate to a -// type with exactly those parameters. -parameters : LessThan ( parameter (Comma parameter)* )? GreaterThan ; - -// Type parameter pattern. The name prefix is only used when evaluated (it is -// never matched), and is currently only accepted by the NSTRUCT (pseudo)type. -parameter : ( identifierOrString Colon )? parameterValue ; - -// A pattern for matching potentially-optional parameter values. "null" may be -// used to match or evaluate to explicitly-skipped optional parameters; -// otherwise, the given pattern is used for the parameter value. The "?" (any) -// pattern is special-cased to also match explicitly-skipped parameter slots. -parameterValue : Null #Null | pattern #Specified; - -// Integer literals. -integer : ( Plus | Minus )? ( Zero | Nonzero ) ; - -// When identifying user-defined types and variations, period-separated -// namespace paths are supported. -identifierPath : ( Identifier Period )* Identifier ; - -// The names of parameters (i.e. NSTRUCT field names) can be specified using -// both identifiers and strings. The latter is idiomatic only when the field -// name is not a valid Substrait identifier. -identifierOrString : String #Str | Identifier #Ident; From 00feec6f83afb6d7425b9389da4711104883036a Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Wed, 4 Sep 2024 18:09:04 +0530 Subject: [PATCH 13/19] review comments --- grammar/SubstraitType.g4 | 24 ------------------------ tests/coverage/extensions.py | 2 +- 2 files changed, 1 insertion(+), 25 deletions(-) diff --git a/grammar/SubstraitType.g4 b/grammar/SubstraitType.g4 index 27a238a8a..a0f05164d 100644 --- a/grammar/SubstraitType.g4 +++ b/grammar/SubstraitType.g4 @@ -2,10 +2,6 @@ grammar SubstraitType; import SubstraitLexer; -If : I F; -Then : T H E N; -Else : E L S E; - // OPERATIONS And : A N D; Or : O R; @@ -48,26 +44,6 @@ Identifier : ('a'..'z' | 'A'..'Z' | '_' | '$') ('a'..'z' | 'A'..'Z' | '_' | '$' | Digit)* ; -LineComment - : '//' ~[\r\n]* -> channel(HIDDEN) - ; - -BlockComment - : ( '/*' - ( '/'* BlockComment - | ~[/*] - | '/'+ ~[/*] - | '*'+ ~[/*] - )* - '*'* - '*/' - ) -> channel(HIDDEN) - ; - -Whitespace - : [ \t]+ -> channel(HIDDEN) - ; - Newline : ( '\r' '\n'? | '\n' diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index e599132a9..ef1cbbec6 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -265,7 +265,7 @@ def add_functions(self, functions, func_type): fun_arr.append(function) self.registry[f_name] = fun_arr - def get_function(self, name, args) -> [FunctionVariant]: + def get_function(self, name: str, args: object) -> [FunctionVariant]: functions = self.registry.get(name, None) if functions is None: return None From 8305ee3c1aa5a4eb6c0665715507a5eef3cd74bb Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Thu, 12 Sep 2024 20:02:41 +0530 Subject: [PATCH 14/19] review comments 1 --- ...{TestFileLexer.g4 => FuncTestCaseLexer.g4} | 2 +- ...estFileParser.g4 => FuncTestCaseParser.g4} | 4 +- grammar/Makefile | 2 +- grammar/SubstraitLexer.g4 | 11 +- grammar/SubstraitType.g4 | 24 +- .../antlr_parser/FuncTestCaseLexer.interp | 333 + .../antlr_parser/FuncTestCaseLexer.py | 599 + ...eLexer.tokens => FuncTestCaseLexer.tokens} | 91 +- ...arser.interp => FuncTestCaseParser.interp} | 14 +- .../antlr_parser/FuncTestCaseParser.py | 4127 +++++++ ...arser.tokens => FuncTestCaseParser.tokens} | 91 +- .../FuncTestCaseParserListener.py | 561 + .../antlr_parser/FuncTestCaseParserVisitor.py | 318 + .../antlr_parser/SubstraitLexer.interp | 25 +- tests/coverage/antlr_parser/SubstraitLexer.py | 5760 +-------- .../antlr_parser/SubstraitLexer.tokens | 91 +- .../antlr_parser/TestFileLexer.interp | 330 - tests/coverage/antlr_parser/TestFileLexer.py | 10066 ---------------- tests/coverage/antlr_parser/TestFileParser.py | 7477 ------------ .../antlr_parser/TestFileParserListener.py | 507 - .../antlr_parser/TestFileParserVisitor.py | 264 - tests/coverage/case_file_parser.py | 8 +- tests/coverage/coverage.py | 50 +- tests/coverage/extensions.py | 91 +- tests/coverage/test_coverage.py | 50 +- tests/coverage/visitor.py | 70 +- tests/test_extensions.py | 32 +- 27 files changed, 6580 insertions(+), 24418 deletions(-) rename grammar/{TestFileLexer.g4 => FuncTestCaseLexer.g4} (98%) rename grammar/{TestFileParser.g4 => FuncTestCaseParser.g4} (98%) create mode 100644 tests/coverage/antlr_parser/FuncTestCaseLexer.interp create mode 100644 tests/coverage/antlr_parser/FuncTestCaseLexer.py rename tests/coverage/antlr_parser/{TestFileLexer.tokens => FuncTestCaseLexer.tokens} (69%) rename tests/coverage/antlr_parser/{TestFileParser.interp => FuncTestCaseParser.interp} (76%) create mode 100644 tests/coverage/antlr_parser/FuncTestCaseParser.py rename tests/coverage/antlr_parser/{TestFileParser.tokens => FuncTestCaseParser.tokens} (69%) create mode 100644 tests/coverage/antlr_parser/FuncTestCaseParserListener.py create mode 100644 tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py delete mode 100644 tests/coverage/antlr_parser/TestFileLexer.interp delete mode 100644 tests/coverage/antlr_parser/TestFileLexer.py delete mode 100644 tests/coverage/antlr_parser/TestFileParser.py delete mode 100644 tests/coverage/antlr_parser/TestFileParserListener.py delete mode 100644 tests/coverage/antlr_parser/TestFileParserVisitor.py diff --git a/grammar/TestFileLexer.g4 b/grammar/FuncTestCaseLexer.g4 similarity index 98% rename from grammar/TestFileLexer.g4 rename to grammar/FuncTestCaseLexer.g4 index 751e56285..ff5711885 100644 --- a/grammar/TestFileLexer.g4 +++ b/grammar/FuncTestCaseLexer.g4 @@ -1,4 +1,4 @@ -lexer grammar TestFileLexer; +lexer grammar FuncTestCaseLexer; import SubstraitLexer; diff --git a/grammar/TestFileParser.g4 b/grammar/FuncTestCaseParser.g4 similarity index 98% rename from grammar/TestFileParser.g4 rename to grammar/FuncTestCaseParser.g4 index 74e32255d..3ee7b1068 100644 --- a/grammar/TestFileParser.g4 +++ b/grammar/FuncTestCaseParser.g4 @@ -1,8 +1,8 @@ -parser grammar TestFileParser; +parser grammar FuncTestCaseParser; options { tokenVocab=SubstraitLexer; - tokenVocab=TestFileLexer; + tokenVocab=FuncTestCaseLexer; } doc diff --git a/grammar/Makefile b/grammar/Makefile index b5dedc915..e94e04e89 100644 --- a/grammar/Makefile +++ b/grammar/Makefile @@ -1,5 +1,5 @@ ANTLR_JAR=antlr-4.13.2-complete.jar -GRAMMARS=SubstraitLexer.g4 TestFileLexer.g4 TestFileParser.g4 +GRAMMARS=SubstraitLexer.g4 FuncTestCaseLexer.g4 FuncTestCaseParser.g4 OUTPUT_DIR=../tests/coverage/antlr_parser generate: diff --git a/grammar/SubstraitLexer.g4 b/grammar/SubstraitLexer.g4 index ba25bd6fe..c2bbf81a1 100644 --- a/grammar/SubstraitLexer.g4 +++ b/grammar/SubstraitLexer.g4 @@ -58,15 +58,15 @@ FP64 : F P '64'; String : S T R I N G; Binary : B I N A R Y; Timestamp: T I M E S T A M P; -TimestampTZ: T I M E S T A M P '_' T Z; +Timestamp_TZ: T I M E S T A M P '_' T Z; Date : D A T E; Time : T I M E; -IntervalYear: I N T E R V A L '_' Y E A R; -IntervalDay: I N T E R V A L '_' D A Y; +Interval_Year: I N T E R V A L '_' Y E A R; +Interval_Day: I N T E R V A L '_' D A Y; UUID : U U I D; Decimal : D E C I M A L; -PrecisionTimestamp: P R E C I S I O N '_' T I M E S T A M P; -PrecisionTimestampTZ: P R E C I S I O N '_' T I M E S T A M P '_' T Z; +Precision_Timestamp: P R E C I S I O N '_' T I M E S T A M P; +Precision_Timestamp_TZ: P R E C I S I O N '_' T I M E S T A M P '_' T Z; FixedChar: F I X E D C H A R; VarChar : V A R C H A R; FixedBinary: F I X E D B I N A R Y; @@ -76,6 +76,7 @@ List : L I S T; Map : M A P; ANY : A N Y; UserDefined: U '!'; +Geometry: G E O M E T R Y; // short names for types Bool: B O O L; diff --git a/grammar/SubstraitType.g4 b/grammar/SubstraitType.g4 index a0f05164d..60849c671 100644 --- a/grammar/SubstraitType.g4 +++ b/grammar/SubstraitType.g4 @@ -73,26 +73,26 @@ scalarType | String #string | Binary #binary | Timestamp #timestamp - | TimestampTZ #timestampTz + | Timestamp_TZ #timestampTz | Date #date | Time #time | IntervalDay #intervalDay - | IntervalYear #intervalYear + | Interval_Year #intervalYear | UUID #uuid | UserDefined Identifier #userDefined ; parameterizedType - : FixedChar isnull=QMark? Lt len=numericParameter Gt #fixedChar - | VarChar isnull=QMark? Lt len=numericParameter Gt #varChar - | FixedBinary isnull=QMark? Lt len=numericParameter Gt #fixedBinary - | Decimal isnull=QMark? Lt precision=numericParameter Comma scale=numericParameter Gt #decimal - | PrecisionTimestamp isnull=QMark? Lt precision=numericParameter Gt #precisionTimestamp - | PrecisionTimestampTZ isnull=QMark? Lt precision=numericParameter Gt #precisionTimestampTZ - | Struct isnull=QMark? Lt expr (Comma expr)* Gt #struct - | NStruct isnull=QMark? Lt Identifier expr (Comma Identifier expr)* Gt #nStruct - | List isnull=QMark? Lt expr Gt #list - | Map isnull=QMark? Lt key=expr Comma value=expr Gt #map + : FixedChar isnull=QMark? Lt len=numericParameter Gt #fixedChar + | VarChar isnull=QMark? Lt len=numericParameter Gt #varChar + | FixedBinary isnull=QMark? Lt len=numericParameter Gt #fixedBinary + | Decimal isnull=QMark? Lt precision=numericParameter Comma scale=numericParameter Gt #decimal + | Precision_Timestamp isnull=QMark? Lt precision=numericParameter Gt #precisionTimestamp + | Precision_Timestamp_TZ isnull=QMark? Lt precision=numericParameter Gt #precisionTimestampTZ + | Struct isnull=QMark? Lt expr (Comma expr)* Gt #struct + | NStruct isnull=QMark? Lt Identifier expr (Comma Identifier expr)* Gt #nStruct + | List isnull=QMark? Lt expr Gt #list + | Map isnull=QMark? Lt key=expr Comma value=expr Gt #map ; numericParameter diff --git a/tests/coverage/antlr_parser/FuncTestCaseLexer.interp b/tests/coverage/antlr_parser/FuncTestCaseLexer.interp new file mode 100644 index 000000000..54d9c8f6d --- /dev/null +++ b/tests/coverage/antlr_parser/FuncTestCaseLexer.interp @@ -0,0 +1,333 @@ +token literal names: +null +'### SUBSTRAIT_SCALAR_TEST:' +null +'### SUBSTRAIT_INCLUDE:' +null +'' +'' +'overlfow' +'rounding' +'ERROR' +'SATURATE' +'SILENT' +'TIE_TO_EVEN' +'NAN' +null +null +null +null +null +null +null +null +'P' +'T' +'Y' +'M' +'D' +'H' +'S' +'F' +null +null +'null' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'::' +null +'<' +'>' +'(' +')' +'[' +']' +',' +'=' +':' +'?' +'#' +'.' + +token symbolic names: +null +SUBSTRAIT_SCALAR_TEST +FORMAT_VERSION +SUBSTRAIT_INCLUDE +DESCRIPTION_LINE +ERROR_RESULT +UNDEFINED_RESULT +OVERFLOW +ROUNDING +ERROR +SATURATE +SILENT +TIE_TO_EVEN +NAN +INTEGER_LITERAL +DECIMAL_LITERAL +FLOAT_LITERAL +BOOLEAN_LITERAL +TIMESTAMP_TZ_LITERAL +TIMESTAMP_LITERAL +TIME_LITERAL +DATE_LITERAL +PERIOD_PREFIX +TIME_PREFIX +YEAR_SUFFIX +M_SUFFIX +DAY_SUFFIX +HOUR_SUFFIX +SECOND_SUFFIX +FRACTIONAL_SECOND_SUFFIX +INTERVAL_YEAR_LITERAL +INTERVAL_DAY_LITERAL +NULL_LITERAL +STRING_LITERAL +LineComment +BlockComment +Whitespace +If +Then +Else +Boolean +I8 +I16 +I32 +I64 +FP32 +FP64 +String +Binary +Timestamp +Timestamp_TZ +Date +Time +Interval_Year +Interval_Day +UUID +Decimal +Precision_Timestamp +Precision_Timestamp_TZ +FixedChar +VarChar +FixedBinary +Struct +NStruct +List +Map +ANY +UserDefined +Geometry +Bool +Str +VBin +Ts +TsTZ +IYear +IDay +Dec +PTs +PTsTZ +FChar +VChar +FBin +DOUBLE_COLON +IDENTIFIER +O_ANGLE_BRACKET +C_ANGLE_BRACKET +OPAREN +CPAREN +OBRACKET +CBRACKET +COMMA +EQ +COLON +QMARK +HASH +DOT + +rule names: +SUBSTRAIT_SCALAR_TEST +FORMAT_VERSION +SUBSTRAIT_INCLUDE +DESCRIPTION_LINE +ERROR_RESULT +UNDEFINED_RESULT +OVERFLOW +ROUNDING +ERROR +SATURATE +SILENT +TIE_TO_EVEN +NAN +INTEGER_LITERAL +DECIMAL_LITERAL +FLOAT_LITERAL +BOOLEAN_LITERAL +FourDigits +TwoDigits +TIMESTAMP_TZ_LITERAL +TIMESTAMP_LITERAL +TIME_LITERAL +DATE_LITERAL +PERIOD_PREFIX +TIME_PREFIX +YEAR_SUFFIX +M_SUFFIX +DAY_SUFFIX +HOUR_SUFFIX +SECOND_SUFFIX +FRACTIONAL_SECOND_SUFFIX +INTERVAL_YEAR_LITERAL +INTERVAL_DAY_LITERAL +TIME_INTERVAL +NULL_LITERAL +STRING_LITERAL +LineComment +BlockComment +Whitespace +A +B +C +D +E +F +G +H +I +J +K +L +M +N +O +P +Q +R +S +T +U +V +W +X +Y +Z +DIGIT +INTEGER +If +Then +Else +Boolean +I8 +I16 +I32 +I64 +FP32 +FP64 +String +Binary +Timestamp +Timestamp_TZ +Date +Time +Interval_Year +Interval_Day +UUID +Decimal +Precision_Timestamp +Precision_Timestamp_TZ +FixedChar +VarChar +FixedBinary +Struct +NStruct +List +Map +ANY +UserDefined +Geometry +Bool +Str +VBin +Ts +TsTZ +IYear +IDay +Dec +PTs +PTsTZ +FChar +VChar +FBin +DOUBLE_COLON +IDENTIFIER +O_ANGLE_BRACKET +C_ANGLE_BRACKET +OPAREN +CPAREN +OBRACKET +CBRACKET +COMMA +EQ +COLON +QMARK +HASH +DOT + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 95, 1129, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 4, 1, 283, 8, 1, 11, 1, 12, 1, 284, 1, 1, 1, 1, 4, 1, 289, 8, 1, 11, 1, 12, 1, 290, 3, 1, 293, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 322, 8, 3, 10, 3, 12, 3, 325, 9, 3, 1, 3, 3, 3, 328, 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 3, 13, 411, 8, 13, 1, 13, 1, 13, 1, 14, 3, 14, 416, 8, 14, 1, 14, 4, 14, 419, 8, 14, 11, 14, 12, 14, 420, 1, 14, 1, 14, 4, 14, 425, 8, 14, 11, 14, 12, 14, 426, 3, 14, 429, 8, 14, 1, 15, 3, 15, 432, 8, 15, 1, 15, 4, 15, 435, 8, 15, 11, 15, 12, 15, 436, 1, 15, 1, 15, 5, 15, 441, 8, 15, 10, 15, 12, 15, 444, 9, 15, 3, 15, 446, 8, 15, 1, 15, 1, 15, 3, 15, 450, 8, 15, 1, 15, 4, 15, 453, 8, 15, 11, 15, 12, 15, 454, 3, 15, 457, 8, 15, 1, 15, 3, 15, 460, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 475, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 486, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 4, 19, 510, 8, 19, 11, 19, 12, 19, 511, 3, 19, 514, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 4, 20, 536, 8, 20, 11, 20, 12, 20, 537, 3, 20, 540, 8, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 4, 21, 552, 8, 21, 11, 21, 12, 21, 553, 3, 21, 556, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 591, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 601, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 610, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 620, 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 627, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 632, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 637, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 644, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 649, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 656, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 661, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 5, 35, 674, 8, 35, 10, 35, 12, 35, 677, 9, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 685, 8, 36, 10, 36, 12, 36, 688, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 4, 37, 697, 8, 37, 11, 37, 12, 37, 698, 1, 37, 3, 37, 702, 8, 37, 1, 37, 5, 37, 705, 8, 37, 10, 37, 12, 37, 708, 9, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 4, 38, 716, 8, 38, 11, 38, 12, 38, 717, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 64, 1, 64, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 5, 66, 779, 8, 66, 10, 66, 12, 66, 782, 9, 66, 3, 66, 784, 8, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 5, 113, 1101, 8, 113, 10, 113, 12, 113, 1104, 9, 113, 1, 114, 1, 114, 1, 115, 1, 115, 1, 116, 1, 116, 1, 117, 1, 117, 1, 118, 1, 118, 1, 119, 1, 119, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 1, 124, 1, 124, 1, 125, 1, 125, 0, 0, 126, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 0, 37, 0, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 30, 65, 31, 67, 0, 69, 32, 71, 33, 73, 34, 75, 35, 77, 36, 79, 0, 81, 0, 83, 0, 85, 0, 87, 0, 89, 0, 91, 0, 93, 0, 95, 0, 97, 0, 99, 0, 101, 0, 103, 0, 105, 0, 107, 0, 109, 0, 111, 0, 113, 0, 115, 0, 117, 0, 119, 0, 121, 0, 123, 0, 125, 0, 127, 0, 129, 0, 131, 0, 133, 0, 135, 37, 137, 38, 139, 39, 141, 40, 143, 41, 145, 42, 147, 43, 149, 44, 151, 45, 153, 46, 155, 47, 157, 48, 159, 49, 161, 50, 163, 51, 165, 52, 167, 53, 169, 54, 171, 55, 173, 56, 175, 57, 177, 58, 179, 59, 181, 60, 183, 61, 185, 62, 187, 63, 189, 64, 191, 65, 193, 66, 195, 67, 197, 68, 199, 69, 201, 70, 203, 71, 205, 72, 207, 73, 209, 74, 211, 75, 213, 76, 215, 77, 217, 78, 219, 79, 221, 80, 223, 81, 225, 82, 227, 83, 229, 84, 231, 85, 233, 86, 235, 87, 237, 88, 239, 89, 241, 90, 243, 91, 245, 92, 247, 93, 249, 94, 251, 95, 1, 0, 36, 2, 0, 10, 10, 13, 13, 2, 0, 43, 43, 45, 45, 1, 0, 48, 57, 2, 0, 69, 69, 101, 101, 2, 0, 39, 39, 92, 92, 1, 0, 42, 42, 2, 0, 42, 42, 47, 47, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 1, 0, 49, 57, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1150, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 1, 253, 1, 0, 0, 0, 3, 280, 1, 0, 0, 0, 5, 294, 1, 0, 0, 0, 7, 317, 1, 0, 0, 0, 9, 331, 1, 0, 0, 0, 11, 340, 1, 0, 0, 0, 13, 353, 1, 0, 0, 0, 15, 362, 1, 0, 0, 0, 17, 371, 1, 0, 0, 0, 19, 377, 1, 0, 0, 0, 21, 386, 1, 0, 0, 0, 23, 393, 1, 0, 0, 0, 25, 405, 1, 0, 0, 0, 27, 410, 1, 0, 0, 0, 29, 415, 1, 0, 0, 0, 31, 474, 1, 0, 0, 0, 33, 485, 1, 0, 0, 0, 35, 487, 1, 0, 0, 0, 37, 492, 1, 0, 0, 0, 39, 495, 1, 0, 0, 0, 41, 521, 1, 0, 0, 0, 43, 543, 1, 0, 0, 0, 45, 559, 1, 0, 0, 0, 47, 567, 1, 0, 0, 0, 49, 569, 1, 0, 0, 0, 51, 571, 1, 0, 0, 0, 53, 573, 1, 0, 0, 0, 55, 575, 1, 0, 0, 0, 57, 577, 1, 0, 0, 0, 59, 579, 1, 0, 0, 0, 61, 581, 1, 0, 0, 0, 63, 600, 1, 0, 0, 0, 65, 619, 1, 0, 0, 0, 67, 660, 1, 0, 0, 0, 69, 662, 1, 0, 0, 0, 71, 667, 1, 0, 0, 0, 73, 680, 1, 0, 0, 0, 75, 691, 1, 0, 0, 0, 77, 715, 1, 0, 0, 0, 79, 721, 1, 0, 0, 0, 81, 723, 1, 0, 0, 0, 83, 725, 1, 0, 0, 0, 85, 727, 1, 0, 0, 0, 87, 729, 1, 0, 0, 0, 89, 731, 1, 0, 0, 0, 91, 733, 1, 0, 0, 0, 93, 735, 1, 0, 0, 0, 95, 737, 1, 0, 0, 0, 97, 739, 1, 0, 0, 0, 99, 741, 1, 0, 0, 0, 101, 743, 1, 0, 0, 0, 103, 745, 1, 0, 0, 0, 105, 747, 1, 0, 0, 0, 107, 749, 1, 0, 0, 0, 109, 751, 1, 0, 0, 0, 111, 753, 1, 0, 0, 0, 113, 755, 1, 0, 0, 0, 115, 757, 1, 0, 0, 0, 117, 759, 1, 0, 0, 0, 119, 761, 1, 0, 0, 0, 121, 763, 1, 0, 0, 0, 123, 765, 1, 0, 0, 0, 125, 767, 1, 0, 0, 0, 127, 769, 1, 0, 0, 0, 129, 771, 1, 0, 0, 0, 131, 773, 1, 0, 0, 0, 133, 783, 1, 0, 0, 0, 135, 785, 1, 0, 0, 0, 137, 788, 1, 0, 0, 0, 139, 793, 1, 0, 0, 0, 141, 798, 1, 0, 0, 0, 143, 806, 1, 0, 0, 0, 145, 809, 1, 0, 0, 0, 147, 813, 1, 0, 0, 0, 149, 817, 1, 0, 0, 0, 151, 821, 1, 0, 0, 0, 153, 826, 1, 0, 0, 0, 155, 831, 1, 0, 0, 0, 157, 838, 1, 0, 0, 0, 159, 845, 1, 0, 0, 0, 161, 855, 1, 0, 0, 0, 163, 868, 1, 0, 0, 0, 165, 873, 1, 0, 0, 0, 167, 878, 1, 0, 0, 0, 169, 892, 1, 0, 0, 0, 171, 905, 1, 0, 0, 0, 173, 910, 1, 0, 0, 0, 175, 918, 1, 0, 0, 0, 177, 938, 1, 0, 0, 0, 179, 961, 1, 0, 0, 0, 181, 971, 1, 0, 0, 0, 183, 979, 1, 0, 0, 0, 185, 991, 1, 0, 0, 0, 187, 998, 1, 0, 0, 0, 189, 1006, 1, 0, 0, 0, 191, 1011, 1, 0, 0, 0, 193, 1015, 1, 0, 0, 0, 195, 1019, 1, 0, 0, 0, 197, 1022, 1, 0, 0, 0, 199, 1031, 1, 0, 0, 0, 201, 1036, 1, 0, 0, 0, 203, 1040, 1, 0, 0, 0, 205, 1045, 1, 0, 0, 0, 207, 1048, 1, 0, 0, 0, 209, 1053, 1, 0, 0, 0, 211, 1059, 1, 0, 0, 0, 213, 1064, 1, 0, 0, 0, 215, 1068, 1, 0, 0, 0, 217, 1072, 1, 0, 0, 0, 219, 1078, 1, 0, 0, 0, 221, 1084, 1, 0, 0, 0, 223, 1090, 1, 0, 0, 0, 225, 1095, 1, 0, 0, 0, 227, 1098, 1, 0, 0, 0, 229, 1105, 1, 0, 0, 0, 231, 1107, 1, 0, 0, 0, 233, 1109, 1, 0, 0, 0, 235, 1111, 1, 0, 0, 0, 237, 1113, 1, 0, 0, 0, 239, 1115, 1, 0, 0, 0, 241, 1117, 1, 0, 0, 0, 243, 1119, 1, 0, 0, 0, 245, 1121, 1, 0, 0, 0, 247, 1123, 1, 0, 0, 0, 249, 1125, 1, 0, 0, 0, 251, 1127, 1, 0, 0, 0, 253, 254, 5, 35, 0, 0, 254, 255, 5, 35, 0, 0, 255, 256, 5, 35, 0, 0, 256, 257, 5, 32, 0, 0, 257, 258, 5, 83, 0, 0, 258, 259, 5, 85, 0, 0, 259, 260, 5, 66, 0, 0, 260, 261, 5, 83, 0, 0, 261, 262, 5, 84, 0, 0, 262, 263, 5, 82, 0, 0, 263, 264, 5, 65, 0, 0, 264, 265, 5, 73, 0, 0, 265, 266, 5, 84, 0, 0, 266, 267, 5, 95, 0, 0, 267, 268, 5, 83, 0, 0, 268, 269, 5, 67, 0, 0, 269, 270, 5, 65, 0, 0, 270, 271, 5, 76, 0, 0, 271, 272, 5, 65, 0, 0, 272, 273, 5, 82, 0, 0, 273, 274, 5, 95, 0, 0, 274, 275, 5, 84, 0, 0, 275, 276, 5, 69, 0, 0, 276, 277, 5, 83, 0, 0, 277, 278, 5, 84, 0, 0, 278, 279, 5, 58, 0, 0, 279, 2, 1, 0, 0, 0, 280, 282, 5, 118, 0, 0, 281, 283, 3, 131, 65, 0, 282, 281, 1, 0, 0, 0, 283, 284, 1, 0, 0, 0, 284, 282, 1, 0, 0, 0, 284, 285, 1, 0, 0, 0, 285, 292, 1, 0, 0, 0, 286, 288, 5, 46, 0, 0, 287, 289, 3, 131, 65, 0, 288, 287, 1, 0, 0, 0, 289, 290, 1, 0, 0, 0, 290, 288, 1, 0, 0, 0, 290, 291, 1, 0, 0, 0, 291, 293, 1, 0, 0, 0, 292, 286, 1, 0, 0, 0, 292, 293, 1, 0, 0, 0, 293, 4, 1, 0, 0, 0, 294, 295, 5, 35, 0, 0, 295, 296, 5, 35, 0, 0, 296, 297, 5, 35, 0, 0, 297, 298, 5, 32, 0, 0, 298, 299, 5, 83, 0, 0, 299, 300, 5, 85, 0, 0, 300, 301, 5, 66, 0, 0, 301, 302, 5, 83, 0, 0, 302, 303, 5, 84, 0, 0, 303, 304, 5, 82, 0, 0, 304, 305, 5, 65, 0, 0, 305, 306, 5, 73, 0, 0, 306, 307, 5, 84, 0, 0, 307, 308, 5, 95, 0, 0, 308, 309, 5, 73, 0, 0, 309, 310, 5, 78, 0, 0, 310, 311, 5, 67, 0, 0, 311, 312, 5, 76, 0, 0, 312, 313, 5, 85, 0, 0, 313, 314, 5, 68, 0, 0, 314, 315, 5, 69, 0, 0, 315, 316, 5, 58, 0, 0, 316, 6, 1, 0, 0, 0, 317, 318, 5, 35, 0, 0, 318, 319, 5, 32, 0, 0, 319, 323, 1, 0, 0, 0, 320, 322, 8, 0, 0, 0, 321, 320, 1, 0, 0, 0, 322, 325, 1, 0, 0, 0, 323, 321, 1, 0, 0, 0, 323, 324, 1, 0, 0, 0, 324, 327, 1, 0, 0, 0, 325, 323, 1, 0, 0, 0, 326, 328, 5, 13, 0, 0, 327, 326, 1, 0, 0, 0, 327, 328, 1, 0, 0, 0, 328, 329, 1, 0, 0, 0, 329, 330, 5, 10, 0, 0, 330, 8, 1, 0, 0, 0, 331, 332, 5, 60, 0, 0, 332, 333, 5, 33, 0, 0, 333, 334, 5, 69, 0, 0, 334, 335, 5, 82, 0, 0, 335, 336, 5, 82, 0, 0, 336, 337, 5, 79, 0, 0, 337, 338, 5, 82, 0, 0, 338, 339, 5, 62, 0, 0, 339, 10, 1, 0, 0, 0, 340, 341, 5, 60, 0, 0, 341, 342, 5, 33, 0, 0, 342, 343, 5, 85, 0, 0, 343, 344, 5, 78, 0, 0, 344, 345, 5, 68, 0, 0, 345, 346, 5, 69, 0, 0, 346, 347, 5, 70, 0, 0, 347, 348, 5, 73, 0, 0, 348, 349, 5, 78, 0, 0, 349, 350, 5, 69, 0, 0, 350, 351, 5, 68, 0, 0, 351, 352, 5, 62, 0, 0, 352, 12, 1, 0, 0, 0, 353, 354, 5, 111, 0, 0, 354, 355, 5, 118, 0, 0, 355, 356, 5, 101, 0, 0, 356, 357, 5, 114, 0, 0, 357, 358, 5, 108, 0, 0, 358, 359, 5, 102, 0, 0, 359, 360, 5, 111, 0, 0, 360, 361, 5, 119, 0, 0, 361, 14, 1, 0, 0, 0, 362, 363, 5, 114, 0, 0, 363, 364, 5, 111, 0, 0, 364, 365, 5, 117, 0, 0, 365, 366, 5, 110, 0, 0, 366, 367, 5, 100, 0, 0, 367, 368, 5, 105, 0, 0, 368, 369, 5, 110, 0, 0, 369, 370, 5, 103, 0, 0, 370, 16, 1, 0, 0, 0, 371, 372, 5, 69, 0, 0, 372, 373, 5, 82, 0, 0, 373, 374, 5, 82, 0, 0, 374, 375, 5, 79, 0, 0, 375, 376, 5, 82, 0, 0, 376, 18, 1, 0, 0, 0, 377, 378, 5, 83, 0, 0, 378, 379, 5, 65, 0, 0, 379, 380, 5, 84, 0, 0, 380, 381, 5, 85, 0, 0, 381, 382, 5, 82, 0, 0, 382, 383, 5, 65, 0, 0, 383, 384, 5, 84, 0, 0, 384, 385, 5, 69, 0, 0, 385, 20, 1, 0, 0, 0, 386, 387, 5, 83, 0, 0, 387, 388, 5, 73, 0, 0, 388, 389, 5, 76, 0, 0, 389, 390, 5, 69, 0, 0, 390, 391, 5, 78, 0, 0, 391, 392, 5, 84, 0, 0, 392, 22, 1, 0, 0, 0, 393, 394, 5, 84, 0, 0, 394, 395, 5, 73, 0, 0, 395, 396, 5, 69, 0, 0, 396, 397, 5, 95, 0, 0, 397, 398, 5, 84, 0, 0, 398, 399, 5, 79, 0, 0, 399, 400, 5, 95, 0, 0, 400, 401, 5, 69, 0, 0, 401, 402, 5, 86, 0, 0, 402, 403, 5, 69, 0, 0, 403, 404, 5, 78, 0, 0, 404, 24, 1, 0, 0, 0, 405, 406, 5, 78, 0, 0, 406, 407, 5, 65, 0, 0, 407, 408, 5, 78, 0, 0, 408, 26, 1, 0, 0, 0, 409, 411, 7, 1, 0, 0, 410, 409, 1, 0, 0, 0, 410, 411, 1, 0, 0, 0, 411, 412, 1, 0, 0, 0, 412, 413, 3, 133, 66, 0, 413, 28, 1, 0, 0, 0, 414, 416, 7, 1, 0, 0, 415, 414, 1, 0, 0, 0, 415, 416, 1, 0, 0, 0, 416, 418, 1, 0, 0, 0, 417, 419, 7, 2, 0, 0, 418, 417, 1, 0, 0, 0, 419, 420, 1, 0, 0, 0, 420, 418, 1, 0, 0, 0, 420, 421, 1, 0, 0, 0, 421, 428, 1, 0, 0, 0, 422, 424, 5, 46, 0, 0, 423, 425, 7, 2, 0, 0, 424, 423, 1, 0, 0, 0, 425, 426, 1, 0, 0, 0, 426, 424, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 429, 1, 0, 0, 0, 428, 422, 1, 0, 0, 0, 428, 429, 1, 0, 0, 0, 429, 30, 1, 0, 0, 0, 430, 432, 7, 1, 0, 0, 431, 430, 1, 0, 0, 0, 431, 432, 1, 0, 0, 0, 432, 434, 1, 0, 0, 0, 433, 435, 7, 2, 0, 0, 434, 433, 1, 0, 0, 0, 435, 436, 1, 0, 0, 0, 436, 434, 1, 0, 0, 0, 436, 437, 1, 0, 0, 0, 437, 445, 1, 0, 0, 0, 438, 442, 5, 46, 0, 0, 439, 441, 7, 2, 0, 0, 440, 439, 1, 0, 0, 0, 441, 444, 1, 0, 0, 0, 442, 440, 1, 0, 0, 0, 442, 443, 1, 0, 0, 0, 443, 446, 1, 0, 0, 0, 444, 442, 1, 0, 0, 0, 445, 438, 1, 0, 0, 0, 445, 446, 1, 0, 0, 0, 446, 456, 1, 0, 0, 0, 447, 449, 7, 3, 0, 0, 448, 450, 7, 1, 0, 0, 449, 448, 1, 0, 0, 0, 449, 450, 1, 0, 0, 0, 450, 452, 1, 0, 0, 0, 451, 453, 7, 2, 0, 0, 452, 451, 1, 0, 0, 0, 453, 454, 1, 0, 0, 0, 454, 452, 1, 0, 0, 0, 454, 455, 1, 0, 0, 0, 455, 457, 1, 0, 0, 0, 456, 447, 1, 0, 0, 0, 456, 457, 1, 0, 0, 0, 457, 475, 1, 0, 0, 0, 458, 460, 7, 1, 0, 0, 459, 458, 1, 0, 0, 0, 459, 460, 1, 0, 0, 0, 460, 461, 1, 0, 0, 0, 461, 462, 5, 105, 0, 0, 462, 463, 5, 110, 0, 0, 463, 475, 5, 102, 0, 0, 464, 465, 5, 110, 0, 0, 465, 466, 5, 97, 0, 0, 466, 475, 5, 110, 0, 0, 467, 468, 5, 78, 0, 0, 468, 469, 5, 97, 0, 0, 469, 475, 5, 78, 0, 0, 470, 471, 5, 115, 0, 0, 471, 472, 5, 110, 0, 0, 472, 473, 5, 97, 0, 0, 473, 475, 5, 110, 0, 0, 474, 431, 1, 0, 0, 0, 474, 459, 1, 0, 0, 0, 474, 464, 1, 0, 0, 0, 474, 467, 1, 0, 0, 0, 474, 470, 1, 0, 0, 0, 475, 32, 1, 0, 0, 0, 476, 477, 5, 116, 0, 0, 477, 478, 5, 114, 0, 0, 478, 479, 5, 117, 0, 0, 479, 486, 5, 101, 0, 0, 480, 481, 5, 102, 0, 0, 481, 482, 5, 97, 0, 0, 482, 483, 5, 108, 0, 0, 483, 484, 5, 115, 0, 0, 484, 486, 5, 101, 0, 0, 485, 476, 1, 0, 0, 0, 485, 480, 1, 0, 0, 0, 486, 34, 1, 0, 0, 0, 487, 488, 7, 2, 0, 0, 488, 489, 7, 2, 0, 0, 489, 490, 7, 2, 0, 0, 490, 491, 7, 2, 0, 0, 491, 36, 1, 0, 0, 0, 492, 493, 7, 2, 0, 0, 493, 494, 7, 2, 0, 0, 494, 38, 1, 0, 0, 0, 495, 496, 5, 39, 0, 0, 496, 497, 3, 35, 17, 0, 497, 498, 5, 45, 0, 0, 498, 499, 3, 37, 18, 0, 499, 500, 5, 45, 0, 0, 500, 501, 3, 37, 18, 0, 501, 502, 5, 84, 0, 0, 502, 503, 3, 37, 18, 0, 503, 504, 5, 58, 0, 0, 504, 505, 3, 37, 18, 0, 505, 506, 5, 58, 0, 0, 506, 513, 3, 37, 18, 0, 507, 509, 5, 46, 0, 0, 508, 510, 7, 2, 0, 0, 509, 508, 1, 0, 0, 0, 510, 511, 1, 0, 0, 0, 511, 509, 1, 0, 0, 0, 511, 512, 1, 0, 0, 0, 512, 514, 1, 0, 0, 0, 513, 507, 1, 0, 0, 0, 513, 514, 1, 0, 0, 0, 514, 515, 1, 0, 0, 0, 515, 516, 7, 1, 0, 0, 516, 517, 3, 37, 18, 0, 517, 518, 5, 58, 0, 0, 518, 519, 3, 37, 18, 0, 519, 520, 5, 39, 0, 0, 520, 40, 1, 0, 0, 0, 521, 522, 5, 39, 0, 0, 522, 523, 3, 35, 17, 0, 523, 524, 5, 45, 0, 0, 524, 525, 3, 37, 18, 0, 525, 526, 5, 45, 0, 0, 526, 527, 3, 37, 18, 0, 527, 528, 5, 84, 0, 0, 528, 529, 3, 37, 18, 0, 529, 530, 5, 58, 0, 0, 530, 531, 3, 37, 18, 0, 531, 532, 5, 58, 0, 0, 532, 539, 3, 37, 18, 0, 533, 535, 5, 46, 0, 0, 534, 536, 7, 2, 0, 0, 535, 534, 1, 0, 0, 0, 536, 537, 1, 0, 0, 0, 537, 535, 1, 0, 0, 0, 537, 538, 1, 0, 0, 0, 538, 540, 1, 0, 0, 0, 539, 533, 1, 0, 0, 0, 539, 540, 1, 0, 0, 0, 540, 541, 1, 0, 0, 0, 541, 542, 5, 39, 0, 0, 542, 42, 1, 0, 0, 0, 543, 544, 5, 39, 0, 0, 544, 545, 3, 37, 18, 0, 545, 546, 5, 58, 0, 0, 546, 547, 3, 37, 18, 0, 547, 548, 5, 58, 0, 0, 548, 555, 3, 37, 18, 0, 549, 551, 5, 46, 0, 0, 550, 552, 7, 2, 0, 0, 551, 550, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 553, 551, 1, 0, 0, 0, 553, 554, 1, 0, 0, 0, 554, 556, 1, 0, 0, 0, 555, 549, 1, 0, 0, 0, 555, 556, 1, 0, 0, 0, 556, 557, 1, 0, 0, 0, 557, 558, 5, 39, 0, 0, 558, 44, 1, 0, 0, 0, 559, 560, 5, 39, 0, 0, 560, 561, 3, 35, 17, 0, 561, 562, 5, 45, 0, 0, 562, 563, 3, 37, 18, 0, 563, 564, 5, 45, 0, 0, 564, 565, 3, 37, 18, 0, 565, 566, 5, 39, 0, 0, 566, 46, 1, 0, 0, 0, 567, 568, 5, 80, 0, 0, 568, 48, 1, 0, 0, 0, 569, 570, 5, 84, 0, 0, 570, 50, 1, 0, 0, 0, 571, 572, 5, 89, 0, 0, 572, 52, 1, 0, 0, 0, 573, 574, 5, 77, 0, 0, 574, 54, 1, 0, 0, 0, 575, 576, 5, 68, 0, 0, 576, 56, 1, 0, 0, 0, 577, 578, 5, 72, 0, 0, 578, 58, 1, 0, 0, 0, 579, 580, 5, 83, 0, 0, 580, 60, 1, 0, 0, 0, 581, 582, 5, 70, 0, 0, 582, 62, 1, 0, 0, 0, 583, 584, 5, 39, 0, 0, 584, 585, 3, 47, 23, 0, 585, 586, 3, 27, 13, 0, 586, 590, 3, 51, 25, 0, 587, 588, 3, 27, 13, 0, 588, 589, 3, 53, 26, 0, 589, 591, 1, 0, 0, 0, 590, 587, 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 592, 1, 0, 0, 0, 592, 593, 5, 39, 0, 0, 593, 601, 1, 0, 0, 0, 594, 595, 5, 39, 0, 0, 595, 596, 3, 47, 23, 0, 596, 597, 3, 27, 13, 0, 597, 598, 3, 53, 26, 0, 598, 599, 5, 39, 0, 0, 599, 601, 1, 0, 0, 0, 600, 583, 1, 0, 0, 0, 600, 594, 1, 0, 0, 0, 601, 64, 1, 0, 0, 0, 602, 603, 5, 39, 0, 0, 603, 604, 3, 47, 23, 0, 604, 605, 3, 27, 13, 0, 605, 609, 3, 55, 27, 0, 606, 607, 3, 49, 24, 0, 607, 608, 3, 67, 33, 0, 608, 610, 1, 0, 0, 0, 609, 606, 1, 0, 0, 0, 609, 610, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 612, 5, 39, 0, 0, 612, 620, 1, 0, 0, 0, 613, 614, 5, 39, 0, 0, 614, 615, 3, 47, 23, 0, 615, 616, 3, 49, 24, 0, 616, 617, 3, 67, 33, 0, 617, 618, 5, 39, 0, 0, 618, 620, 1, 0, 0, 0, 619, 602, 1, 0, 0, 0, 619, 613, 1, 0, 0, 0, 620, 66, 1, 0, 0, 0, 621, 622, 3, 27, 13, 0, 622, 626, 3, 57, 28, 0, 623, 624, 3, 27, 13, 0, 624, 625, 3, 53, 26, 0, 625, 627, 1, 0, 0, 0, 626, 623, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 631, 1, 0, 0, 0, 628, 629, 3, 27, 13, 0, 629, 630, 3, 59, 29, 0, 630, 632, 1, 0, 0, 0, 631, 628, 1, 0, 0, 0, 631, 632, 1, 0, 0, 0, 632, 636, 1, 0, 0, 0, 633, 634, 3, 27, 13, 0, 634, 635, 3, 61, 30, 0, 635, 637, 1, 0, 0, 0, 636, 633, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 661, 1, 0, 0, 0, 638, 639, 3, 27, 13, 0, 639, 643, 3, 53, 26, 0, 640, 641, 3, 27, 13, 0, 641, 642, 3, 59, 29, 0, 642, 644, 1, 0, 0, 0, 643, 640, 1, 0, 0, 0, 643, 644, 1, 0, 0, 0, 644, 648, 1, 0, 0, 0, 645, 646, 3, 27, 13, 0, 646, 647, 3, 61, 30, 0, 647, 649, 1, 0, 0, 0, 648, 645, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 661, 1, 0, 0, 0, 650, 651, 3, 27, 13, 0, 651, 655, 3, 59, 29, 0, 652, 653, 3, 27, 13, 0, 653, 654, 3, 61, 30, 0, 654, 656, 1, 0, 0, 0, 655, 652, 1, 0, 0, 0, 655, 656, 1, 0, 0, 0, 656, 661, 1, 0, 0, 0, 657, 658, 3, 27, 13, 0, 658, 659, 3, 61, 30, 0, 659, 661, 1, 0, 0, 0, 660, 621, 1, 0, 0, 0, 660, 638, 1, 0, 0, 0, 660, 650, 1, 0, 0, 0, 660, 657, 1, 0, 0, 0, 661, 68, 1, 0, 0, 0, 662, 663, 5, 110, 0, 0, 663, 664, 5, 117, 0, 0, 664, 665, 5, 108, 0, 0, 665, 666, 5, 108, 0, 0, 666, 70, 1, 0, 0, 0, 667, 675, 5, 39, 0, 0, 668, 669, 5, 92, 0, 0, 669, 674, 9, 0, 0, 0, 670, 671, 5, 39, 0, 0, 671, 674, 5, 39, 0, 0, 672, 674, 8, 4, 0, 0, 673, 668, 1, 0, 0, 0, 673, 670, 1, 0, 0, 0, 673, 672, 1, 0, 0, 0, 674, 677, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 675, 676, 1, 0, 0, 0, 676, 678, 1, 0, 0, 0, 677, 675, 1, 0, 0, 0, 678, 679, 5, 39, 0, 0, 679, 72, 1, 0, 0, 0, 680, 681, 5, 47, 0, 0, 681, 682, 5, 47, 0, 0, 682, 686, 1, 0, 0, 0, 683, 685, 8, 0, 0, 0, 684, 683, 1, 0, 0, 0, 685, 688, 1, 0, 0, 0, 686, 684, 1, 0, 0, 0, 686, 687, 1, 0, 0, 0, 687, 689, 1, 0, 0, 0, 688, 686, 1, 0, 0, 0, 689, 690, 6, 36, 0, 0, 690, 74, 1, 0, 0, 0, 691, 692, 5, 47, 0, 0, 692, 693, 5, 42, 0, 0, 693, 701, 1, 0, 0, 0, 694, 702, 8, 5, 0, 0, 695, 697, 5, 42, 0, 0, 696, 695, 1, 0, 0, 0, 697, 698, 1, 0, 0, 0, 698, 696, 1, 0, 0, 0, 698, 699, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 702, 8, 6, 0, 0, 701, 694, 1, 0, 0, 0, 701, 696, 1, 0, 0, 0, 702, 706, 1, 0, 0, 0, 703, 705, 5, 42, 0, 0, 704, 703, 1, 0, 0, 0, 705, 708, 1, 0, 0, 0, 706, 704, 1, 0, 0, 0, 706, 707, 1, 0, 0, 0, 707, 709, 1, 0, 0, 0, 708, 706, 1, 0, 0, 0, 709, 710, 5, 42, 0, 0, 710, 711, 5, 47, 0, 0, 711, 712, 1, 0, 0, 0, 712, 713, 6, 37, 0, 0, 713, 76, 1, 0, 0, 0, 714, 716, 7, 7, 0, 0, 715, 714, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 717, 718, 1, 0, 0, 0, 718, 719, 1, 0, 0, 0, 719, 720, 6, 38, 0, 0, 720, 78, 1, 0, 0, 0, 721, 722, 7, 8, 0, 0, 722, 80, 1, 0, 0, 0, 723, 724, 7, 9, 0, 0, 724, 82, 1, 0, 0, 0, 725, 726, 7, 10, 0, 0, 726, 84, 1, 0, 0, 0, 727, 728, 7, 11, 0, 0, 728, 86, 1, 0, 0, 0, 729, 730, 7, 3, 0, 0, 730, 88, 1, 0, 0, 0, 731, 732, 7, 12, 0, 0, 732, 90, 1, 0, 0, 0, 733, 734, 7, 13, 0, 0, 734, 92, 1, 0, 0, 0, 735, 736, 7, 14, 0, 0, 736, 94, 1, 0, 0, 0, 737, 738, 7, 15, 0, 0, 738, 96, 1, 0, 0, 0, 739, 740, 7, 16, 0, 0, 740, 98, 1, 0, 0, 0, 741, 742, 7, 17, 0, 0, 742, 100, 1, 0, 0, 0, 743, 744, 7, 18, 0, 0, 744, 102, 1, 0, 0, 0, 745, 746, 7, 19, 0, 0, 746, 104, 1, 0, 0, 0, 747, 748, 7, 20, 0, 0, 748, 106, 1, 0, 0, 0, 749, 750, 7, 21, 0, 0, 750, 108, 1, 0, 0, 0, 751, 752, 7, 22, 0, 0, 752, 110, 1, 0, 0, 0, 753, 754, 7, 23, 0, 0, 754, 112, 1, 0, 0, 0, 755, 756, 7, 24, 0, 0, 756, 114, 1, 0, 0, 0, 757, 758, 7, 25, 0, 0, 758, 116, 1, 0, 0, 0, 759, 760, 7, 26, 0, 0, 760, 118, 1, 0, 0, 0, 761, 762, 7, 27, 0, 0, 762, 120, 1, 0, 0, 0, 763, 764, 7, 28, 0, 0, 764, 122, 1, 0, 0, 0, 765, 766, 7, 29, 0, 0, 766, 124, 1, 0, 0, 0, 767, 768, 7, 30, 0, 0, 768, 126, 1, 0, 0, 0, 769, 770, 7, 31, 0, 0, 770, 128, 1, 0, 0, 0, 771, 772, 7, 32, 0, 0, 772, 130, 1, 0, 0, 0, 773, 774, 7, 2, 0, 0, 774, 132, 1, 0, 0, 0, 775, 784, 5, 48, 0, 0, 776, 780, 7, 33, 0, 0, 777, 779, 7, 2, 0, 0, 778, 777, 1, 0, 0, 0, 779, 782, 1, 0, 0, 0, 780, 778, 1, 0, 0, 0, 780, 781, 1, 0, 0, 0, 781, 784, 1, 0, 0, 0, 782, 780, 1, 0, 0, 0, 783, 775, 1, 0, 0, 0, 783, 776, 1, 0, 0, 0, 784, 134, 1, 0, 0, 0, 785, 786, 3, 95, 47, 0, 786, 787, 3, 89, 44, 0, 787, 136, 1, 0, 0, 0, 788, 789, 3, 117, 58, 0, 789, 790, 3, 93, 46, 0, 790, 791, 3, 87, 43, 0, 791, 792, 3, 105, 52, 0, 792, 138, 1, 0, 0, 0, 793, 794, 3, 87, 43, 0, 794, 795, 3, 101, 50, 0, 795, 796, 3, 115, 57, 0, 796, 797, 3, 87, 43, 0, 797, 140, 1, 0, 0, 0, 798, 799, 3, 81, 40, 0, 799, 800, 3, 107, 53, 0, 800, 801, 3, 107, 53, 0, 801, 802, 3, 101, 50, 0, 802, 803, 3, 87, 43, 0, 803, 804, 3, 79, 39, 0, 804, 805, 3, 105, 52, 0, 805, 142, 1, 0, 0, 0, 806, 807, 3, 95, 47, 0, 807, 808, 5, 56, 0, 0, 808, 144, 1, 0, 0, 0, 809, 810, 3, 95, 47, 0, 810, 811, 5, 49, 0, 0, 811, 812, 5, 54, 0, 0, 812, 146, 1, 0, 0, 0, 813, 814, 3, 95, 47, 0, 814, 815, 5, 51, 0, 0, 815, 816, 5, 50, 0, 0, 816, 148, 1, 0, 0, 0, 817, 818, 3, 95, 47, 0, 818, 819, 5, 54, 0, 0, 819, 820, 5, 52, 0, 0, 820, 150, 1, 0, 0, 0, 821, 822, 3, 89, 44, 0, 822, 823, 3, 109, 54, 0, 823, 824, 5, 51, 0, 0, 824, 825, 5, 50, 0, 0, 825, 152, 1, 0, 0, 0, 826, 827, 3, 89, 44, 0, 827, 828, 3, 109, 54, 0, 828, 829, 5, 54, 0, 0, 829, 830, 5, 52, 0, 0, 830, 154, 1, 0, 0, 0, 831, 832, 3, 115, 57, 0, 832, 833, 3, 117, 58, 0, 833, 834, 3, 113, 56, 0, 834, 835, 3, 95, 47, 0, 835, 836, 3, 105, 52, 0, 836, 837, 3, 91, 45, 0, 837, 156, 1, 0, 0, 0, 838, 839, 3, 81, 40, 0, 839, 840, 3, 95, 47, 0, 840, 841, 3, 105, 52, 0, 841, 842, 3, 79, 39, 0, 842, 843, 3, 113, 56, 0, 843, 844, 3, 127, 63, 0, 844, 158, 1, 0, 0, 0, 845, 846, 3, 117, 58, 0, 846, 847, 3, 95, 47, 0, 847, 848, 3, 103, 51, 0, 848, 849, 3, 87, 43, 0, 849, 850, 3, 115, 57, 0, 850, 851, 3, 117, 58, 0, 851, 852, 3, 79, 39, 0, 852, 853, 3, 103, 51, 0, 853, 854, 3, 109, 54, 0, 854, 160, 1, 0, 0, 0, 855, 856, 3, 117, 58, 0, 856, 857, 3, 95, 47, 0, 857, 858, 3, 103, 51, 0, 858, 859, 3, 87, 43, 0, 859, 860, 3, 115, 57, 0, 860, 861, 3, 117, 58, 0, 861, 862, 3, 79, 39, 0, 862, 863, 3, 103, 51, 0, 863, 864, 3, 109, 54, 0, 864, 865, 5, 95, 0, 0, 865, 866, 3, 117, 58, 0, 866, 867, 3, 129, 64, 0, 867, 162, 1, 0, 0, 0, 868, 869, 3, 85, 42, 0, 869, 870, 3, 79, 39, 0, 870, 871, 3, 117, 58, 0, 871, 872, 3, 87, 43, 0, 872, 164, 1, 0, 0, 0, 873, 874, 3, 117, 58, 0, 874, 875, 3, 95, 47, 0, 875, 876, 3, 103, 51, 0, 876, 877, 3, 87, 43, 0, 877, 166, 1, 0, 0, 0, 878, 879, 3, 95, 47, 0, 879, 880, 3, 105, 52, 0, 880, 881, 3, 117, 58, 0, 881, 882, 3, 87, 43, 0, 882, 883, 3, 113, 56, 0, 883, 884, 3, 121, 60, 0, 884, 885, 3, 79, 39, 0, 885, 886, 3, 101, 50, 0, 886, 887, 5, 95, 0, 0, 887, 888, 3, 127, 63, 0, 888, 889, 3, 87, 43, 0, 889, 890, 3, 79, 39, 0, 890, 891, 3, 113, 56, 0, 891, 168, 1, 0, 0, 0, 892, 893, 3, 95, 47, 0, 893, 894, 3, 105, 52, 0, 894, 895, 3, 117, 58, 0, 895, 896, 3, 87, 43, 0, 896, 897, 3, 113, 56, 0, 897, 898, 3, 121, 60, 0, 898, 899, 3, 79, 39, 0, 899, 900, 3, 101, 50, 0, 900, 901, 5, 95, 0, 0, 901, 902, 3, 85, 42, 0, 902, 903, 3, 79, 39, 0, 903, 904, 3, 127, 63, 0, 904, 170, 1, 0, 0, 0, 905, 906, 3, 119, 59, 0, 906, 907, 3, 119, 59, 0, 907, 908, 3, 95, 47, 0, 908, 909, 3, 85, 42, 0, 909, 172, 1, 0, 0, 0, 910, 911, 3, 85, 42, 0, 911, 912, 3, 87, 43, 0, 912, 913, 3, 83, 41, 0, 913, 914, 3, 95, 47, 0, 914, 915, 3, 103, 51, 0, 915, 916, 3, 79, 39, 0, 916, 917, 3, 101, 50, 0, 917, 174, 1, 0, 0, 0, 918, 919, 3, 109, 54, 0, 919, 920, 3, 113, 56, 0, 920, 921, 3, 87, 43, 0, 921, 922, 3, 83, 41, 0, 922, 923, 3, 95, 47, 0, 923, 924, 3, 115, 57, 0, 924, 925, 3, 95, 47, 0, 925, 926, 3, 107, 53, 0, 926, 927, 3, 105, 52, 0, 927, 928, 5, 95, 0, 0, 928, 929, 3, 117, 58, 0, 929, 930, 3, 95, 47, 0, 930, 931, 3, 103, 51, 0, 931, 932, 3, 87, 43, 0, 932, 933, 3, 115, 57, 0, 933, 934, 3, 117, 58, 0, 934, 935, 3, 79, 39, 0, 935, 936, 3, 103, 51, 0, 936, 937, 3, 109, 54, 0, 937, 176, 1, 0, 0, 0, 938, 939, 3, 109, 54, 0, 939, 940, 3, 113, 56, 0, 940, 941, 3, 87, 43, 0, 941, 942, 3, 83, 41, 0, 942, 943, 3, 95, 47, 0, 943, 944, 3, 115, 57, 0, 944, 945, 3, 95, 47, 0, 945, 946, 3, 107, 53, 0, 946, 947, 3, 105, 52, 0, 947, 948, 5, 95, 0, 0, 948, 949, 3, 117, 58, 0, 949, 950, 3, 95, 47, 0, 950, 951, 3, 103, 51, 0, 951, 952, 3, 87, 43, 0, 952, 953, 3, 115, 57, 0, 953, 954, 3, 117, 58, 0, 954, 955, 3, 79, 39, 0, 955, 956, 3, 103, 51, 0, 956, 957, 3, 109, 54, 0, 957, 958, 5, 95, 0, 0, 958, 959, 3, 117, 58, 0, 959, 960, 3, 129, 64, 0, 960, 178, 1, 0, 0, 0, 961, 962, 3, 89, 44, 0, 962, 963, 3, 95, 47, 0, 963, 964, 3, 125, 62, 0, 964, 965, 3, 87, 43, 0, 965, 966, 3, 85, 42, 0, 966, 967, 3, 83, 41, 0, 967, 968, 3, 93, 46, 0, 968, 969, 3, 79, 39, 0, 969, 970, 3, 113, 56, 0, 970, 180, 1, 0, 0, 0, 971, 972, 3, 121, 60, 0, 972, 973, 3, 79, 39, 0, 973, 974, 3, 113, 56, 0, 974, 975, 3, 83, 41, 0, 975, 976, 3, 93, 46, 0, 976, 977, 3, 79, 39, 0, 977, 978, 3, 113, 56, 0, 978, 182, 1, 0, 0, 0, 979, 980, 3, 89, 44, 0, 980, 981, 3, 95, 47, 0, 981, 982, 3, 125, 62, 0, 982, 983, 3, 87, 43, 0, 983, 984, 3, 85, 42, 0, 984, 985, 3, 81, 40, 0, 985, 986, 3, 95, 47, 0, 986, 987, 3, 105, 52, 0, 987, 988, 3, 79, 39, 0, 988, 989, 3, 113, 56, 0, 989, 990, 3, 127, 63, 0, 990, 184, 1, 0, 0, 0, 991, 992, 3, 115, 57, 0, 992, 993, 3, 117, 58, 0, 993, 994, 3, 113, 56, 0, 994, 995, 3, 119, 59, 0, 995, 996, 3, 83, 41, 0, 996, 997, 3, 117, 58, 0, 997, 186, 1, 0, 0, 0, 998, 999, 3, 105, 52, 0, 999, 1000, 3, 115, 57, 0, 1000, 1001, 3, 117, 58, 0, 1001, 1002, 3, 113, 56, 0, 1002, 1003, 3, 119, 59, 0, 1003, 1004, 3, 83, 41, 0, 1004, 1005, 3, 117, 58, 0, 1005, 188, 1, 0, 0, 0, 1006, 1007, 3, 101, 50, 0, 1007, 1008, 3, 95, 47, 0, 1008, 1009, 3, 115, 57, 0, 1009, 1010, 3, 117, 58, 0, 1010, 190, 1, 0, 0, 0, 1011, 1012, 3, 103, 51, 0, 1012, 1013, 3, 79, 39, 0, 1013, 1014, 3, 109, 54, 0, 1014, 192, 1, 0, 0, 0, 1015, 1016, 3, 79, 39, 0, 1016, 1017, 3, 105, 52, 0, 1017, 1018, 3, 127, 63, 0, 1018, 194, 1, 0, 0, 0, 1019, 1020, 3, 119, 59, 0, 1020, 1021, 5, 33, 0, 0, 1021, 196, 1, 0, 0, 0, 1022, 1023, 3, 91, 45, 0, 1023, 1024, 3, 87, 43, 0, 1024, 1025, 3, 107, 53, 0, 1025, 1026, 3, 103, 51, 0, 1026, 1027, 3, 87, 43, 0, 1027, 1028, 3, 117, 58, 0, 1028, 1029, 3, 113, 56, 0, 1029, 1030, 3, 127, 63, 0, 1030, 198, 1, 0, 0, 0, 1031, 1032, 3, 81, 40, 0, 1032, 1033, 3, 107, 53, 0, 1033, 1034, 3, 107, 53, 0, 1034, 1035, 3, 101, 50, 0, 1035, 200, 1, 0, 0, 0, 1036, 1037, 3, 115, 57, 0, 1037, 1038, 3, 117, 58, 0, 1038, 1039, 3, 113, 56, 0, 1039, 202, 1, 0, 0, 0, 1040, 1041, 3, 121, 60, 0, 1041, 1042, 3, 81, 40, 0, 1042, 1043, 3, 95, 47, 0, 1043, 1044, 3, 105, 52, 0, 1044, 204, 1, 0, 0, 0, 1045, 1046, 3, 117, 58, 0, 1046, 1047, 3, 115, 57, 0, 1047, 206, 1, 0, 0, 0, 1048, 1049, 3, 117, 58, 0, 1049, 1050, 3, 115, 57, 0, 1050, 1051, 3, 117, 58, 0, 1051, 1052, 3, 129, 64, 0, 1052, 208, 1, 0, 0, 0, 1053, 1054, 3, 95, 47, 0, 1054, 1055, 3, 127, 63, 0, 1055, 1056, 3, 87, 43, 0, 1056, 1057, 3, 79, 39, 0, 1057, 1058, 3, 113, 56, 0, 1058, 210, 1, 0, 0, 0, 1059, 1060, 3, 95, 47, 0, 1060, 1061, 3, 85, 42, 0, 1061, 1062, 3, 79, 39, 0, 1062, 1063, 3, 127, 63, 0, 1063, 212, 1, 0, 0, 0, 1064, 1065, 3, 85, 42, 0, 1065, 1066, 3, 87, 43, 0, 1066, 1067, 3, 83, 41, 0, 1067, 214, 1, 0, 0, 0, 1068, 1069, 3, 109, 54, 0, 1069, 1070, 3, 117, 58, 0, 1070, 1071, 3, 115, 57, 0, 1071, 216, 1, 0, 0, 0, 1072, 1073, 3, 109, 54, 0, 1073, 1074, 3, 117, 58, 0, 1074, 1075, 3, 115, 57, 0, 1075, 1076, 3, 117, 58, 0, 1076, 1077, 3, 129, 64, 0, 1077, 218, 1, 0, 0, 0, 1078, 1079, 3, 89, 44, 0, 1079, 1080, 3, 83, 41, 0, 1080, 1081, 3, 93, 46, 0, 1081, 1082, 3, 79, 39, 0, 1082, 1083, 3, 113, 56, 0, 1083, 220, 1, 0, 0, 0, 1084, 1085, 3, 121, 60, 0, 1085, 1086, 3, 83, 41, 0, 1086, 1087, 3, 93, 46, 0, 1087, 1088, 3, 79, 39, 0, 1088, 1089, 3, 113, 56, 0, 1089, 222, 1, 0, 0, 0, 1090, 1091, 3, 89, 44, 0, 1091, 1092, 3, 81, 40, 0, 1092, 1093, 3, 95, 47, 0, 1093, 1094, 3, 105, 52, 0, 1094, 224, 1, 0, 0, 0, 1095, 1096, 5, 58, 0, 0, 1096, 1097, 5, 58, 0, 0, 1097, 226, 1, 0, 0, 0, 1098, 1102, 7, 34, 0, 0, 1099, 1101, 7, 35, 0, 0, 1100, 1099, 1, 0, 0, 0, 1101, 1104, 1, 0, 0, 0, 1102, 1100, 1, 0, 0, 0, 1102, 1103, 1, 0, 0, 0, 1103, 228, 1, 0, 0, 0, 1104, 1102, 1, 0, 0, 0, 1105, 1106, 5, 60, 0, 0, 1106, 230, 1, 0, 0, 0, 1107, 1108, 5, 62, 0, 0, 1108, 232, 1, 0, 0, 0, 1109, 1110, 5, 40, 0, 0, 1110, 234, 1, 0, 0, 0, 1111, 1112, 5, 41, 0, 0, 1112, 236, 1, 0, 0, 0, 1113, 1114, 5, 91, 0, 0, 1114, 238, 1, 0, 0, 0, 1115, 1116, 5, 93, 0, 0, 1116, 240, 1, 0, 0, 0, 1117, 1118, 5, 44, 0, 0, 1118, 242, 1, 0, 0, 0, 1119, 1120, 5, 61, 0, 0, 1120, 244, 1, 0, 0, 0, 1121, 1122, 5, 58, 0, 0, 1122, 246, 1, 0, 0, 0, 1123, 1124, 5, 63, 0, 0, 1124, 248, 1, 0, 0, 0, 1125, 1126, 5, 35, 0, 0, 1126, 250, 1, 0, 0, 0, 1127, 1128, 5, 46, 0, 0, 1128, 252, 1, 0, 0, 0, 48, 0, 284, 290, 292, 323, 327, 410, 415, 420, 426, 428, 431, 436, 442, 445, 449, 454, 456, 459, 474, 485, 511, 513, 537, 539, 553, 555, 590, 600, 609, 619, 626, 631, 636, 643, 648, 655, 660, 673, 675, 686, 698, 701, 706, 717, 780, 783, 1102, 1, 0, 1, 0] \ No newline at end of file diff --git a/tests/coverage/antlr_parser/FuncTestCaseLexer.py b/tests/coverage/antlr_parser/FuncTestCaseLexer.py new file mode 100644 index 000000000..e68b3cae4 --- /dev/null +++ b/tests/coverage/antlr_parser/FuncTestCaseLexer.py @@ -0,0 +1,599 @@ +# Generated from FuncTestCaseLexer.g4 by ANTLR 4.13.2 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + + +def serializedATN(): + return [ + 4,0,95,1129,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, + 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, + 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, + 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, + 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, + 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, + 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, + 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, + 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, + 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, + 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, + 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, + 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, + 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2, + 91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7, + 97,2,98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103, + 7,103,2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108, + 2,109,7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114, + 7,114,2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119, + 2,120,7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125, + 7,125,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1, + 0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,4,1,283, + 8,1,11,1,12,1,284,1,1,1,1,4,1,289,8,1,11,1,12,1,290,3,1,293,8,1, + 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2, + 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,5,3,322,8,3,10,3,12, + 3,325,9,3,1,3,3,3,328,8,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1, + 4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,6,1, + 6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, + 7,1,8,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1, + 10,1,10,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,1, + 11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13,3,13,411,8, + 13,1,13,1,13,1,14,3,14,416,8,14,1,14,4,14,419,8,14,11,14,12,14,420, + 1,14,1,14,4,14,425,8,14,11,14,12,14,426,3,14,429,8,14,1,15,3,15, + 432,8,15,1,15,4,15,435,8,15,11,15,12,15,436,1,15,1,15,5,15,441,8, + 15,10,15,12,15,444,9,15,3,15,446,8,15,1,15,1,15,3,15,450,8,15,1, + 15,4,15,453,8,15,11,15,12,15,454,3,15,457,8,15,1,15,3,15,460,8,15, + 1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15, + 3,15,475,8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16, + 486,8,16,1,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19, + 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,4,19,510, + 8,19,11,19,12,19,511,3,19,514,8,19,1,19,1,19,1,19,1,19,1,19,1,19, + 1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20, + 1,20,4,20,536,8,20,11,20,12,20,537,3,20,540,8,20,1,20,1,20,1,21, + 1,21,1,21,1,21,1,21,1,21,1,21,1,21,4,21,552,8,21,11,21,12,21,553, + 3,21,556,8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, + 1,23,1,23,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29, + 1,29,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,591,8,31, + 1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,601,8,31,1,32,1,32, + 1,32,1,32,1,32,1,32,1,32,3,32,610,8,32,1,32,1,32,1,32,1,32,1,32, + 1,32,1,32,1,32,3,32,620,8,32,1,33,1,33,1,33,1,33,1,33,3,33,627,8, + 33,1,33,1,33,1,33,3,33,632,8,33,1,33,1,33,1,33,3,33,637,8,33,1,33, + 1,33,1,33,1,33,1,33,3,33,644,8,33,1,33,1,33,1,33,3,33,649,8,33,1, + 33,1,33,1,33,1,33,1,33,3,33,656,8,33,1,33,1,33,1,33,3,33,661,8,33, + 1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,5,35,674, + 8,35,10,35,12,35,677,9,35,1,35,1,35,1,36,1,36,1,36,1,36,5,36,685, + 8,36,10,36,12,36,688,9,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,4,37, + 697,8,37,11,37,12,37,698,1,37,3,37,702,8,37,1,37,5,37,705,8,37,10, + 37,12,37,708,9,37,1,37,1,37,1,37,1,37,1,37,1,38,4,38,716,8,38,11, + 38,12,38,717,1,38,1,38,1,39,1,39,1,40,1,40,1,41,1,41,1,42,1,42,1, + 43,1,43,1,44,1,44,1,45,1,45,1,46,1,46,1,47,1,47,1,48,1,48,1,49,1, + 49,1,50,1,50,1,51,1,51,1,52,1,52,1,53,1,53,1,54,1,54,1,55,1,55,1, + 56,1,56,1,57,1,57,1,58,1,58,1,59,1,59,1,60,1,60,1,61,1,61,1,62,1, + 62,1,63,1,63,1,64,1,64,1,65,1,65,1,66,1,66,1,66,5,66,779,8,66,10, + 66,12,66,782,9,66,3,66,784,8,66,1,67,1,67,1,67,1,68,1,68,1,68,1, + 68,1,68,1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1, + 70,1,70,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1, + 74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1, + 76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1, + 78,1,78,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1, + 80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,81,1, + 81,1,81,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,83,1,83,1,83,1,83,1, + 83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,84,1, + 84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,85,1,85,1,85,1, + 85,1,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1, + 87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1, + 87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1, + 88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1, + 88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,90,1,90,1, + 90,1,90,1,90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1, + 91,1,91,1,91,1,91,1,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,93,1, + 93,1,93,1,93,1,93,1,93,1,93,1,93,1,94,1,94,1,94,1,94,1,94,1,95,1, + 95,1,95,1,95,1,96,1,96,1,96,1,96,1,97,1,97,1,97,1,98,1,98,1,98,1, + 98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,100,1,100, + 1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,102,1,102,1,102,1,103, + 1,103,1,103,1,103,1,103,1,104,1,104,1,104,1,104,1,104,1,104,1,105, + 1,105,1,105,1,105,1,105,1,106,1,106,1,106,1,106,1,107,1,107,1,107, + 1,107,1,108,1,108,1,108,1,108,1,108,1,108,1,109,1,109,1,109,1,109, + 1,109,1,109,1,110,1,110,1,110,1,110,1,110,1,110,1,111,1,111,1,111, + 1,111,1,111,1,112,1,112,1,112,1,113,1,113,5,113,1101,8,113,10,113, + 12,113,1104,9,113,1,114,1,114,1,115,1,115,1,116,1,116,1,117,1,117, + 1,118,1,118,1,119,1,119,1,120,1,120,1,121,1,121,1,122,1,122,1,123, + 1,123,1,124,1,124,1,125,1,125,0,0,126,1,1,3,2,5,3,7,4,9,5,11,6,13, + 7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,15,31,16,33,17,35,0, + 37,0,39,18,41,19,43,20,45,21,47,22,49,23,51,24,53,25,55,26,57,27, + 59,28,61,29,63,30,65,31,67,0,69,32,71,33,73,34,75,35,77,36,79,0, + 81,0,83,0,85,0,87,0,89,0,91,0,93,0,95,0,97,0,99,0,101,0,103,0,105, + 0,107,0,109,0,111,0,113,0,115,0,117,0,119,0,121,0,123,0,125,0,127, + 0,129,0,131,0,133,0,135,37,137,38,139,39,141,40,143,41,145,42,147, + 43,149,44,151,45,153,46,155,47,157,48,159,49,161,50,163,51,165,52, + 167,53,169,54,171,55,173,56,175,57,177,58,179,59,181,60,183,61,185, + 62,187,63,189,64,191,65,193,66,195,67,197,68,199,69,201,70,203,71, + 205,72,207,73,209,74,211,75,213,76,215,77,217,78,219,79,221,80,223, + 81,225,82,227,83,229,84,231,85,233,86,235,87,237,88,239,89,241,90, + 243,91,245,92,247,93,249,94,251,95,1,0,36,2,0,10,10,13,13,2,0,43, + 43,45,45,1,0,48,57,2,0,69,69,101,101,2,0,39,39,92,92,1,0,42,42,2, + 0,42,42,47,47,3,0,9,10,13,13,32,32,2,0,65,65,97,97,2,0,66,66,98, + 98,2,0,67,67,99,99,2,0,68,68,100,100,2,0,70,70,102,102,2,0,71,71, + 103,103,2,0,72,72,104,104,2,0,73,73,105,105,2,0,74,74,106,106,2, + 0,75,75,107,107,2,0,76,76,108,108,2,0,77,77,109,109,2,0,78,78,110, + 110,2,0,79,79,111,111,2,0,80,80,112,112,2,0,81,81,113,113,2,0,82, + 82,114,114,2,0,83,83,115,115,2,0,84,84,116,116,2,0,85,85,117,117, + 2,0,86,86,118,118,2,0,87,87,119,119,2,0,88,88,120,120,2,0,89,89, + 121,121,2,0,90,90,122,122,1,0,49,57,3,0,65,90,95,95,97,122,4,0,48, + 57,65,90,95,95,97,122,1150,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0, + 7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17, + 1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27, + 1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,39,1,0,0,0,0,41, + 1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51, + 1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61, + 1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73, + 1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0, + 139,1,0,0,0,0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0, + 0,0,0,149,1,0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157, + 1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0, + 0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1, + 0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,0,0,0,0,183,1,0,0,0,0, + 185,1,0,0,0,0,187,1,0,0,0,0,189,1,0,0,0,0,191,1,0,0,0,0,193,1,0, + 0,0,0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0,0,0,0,201,1,0,0,0,0,203, + 1,0,0,0,0,205,1,0,0,0,0,207,1,0,0,0,0,209,1,0,0,0,0,211,1,0,0,0, + 0,213,1,0,0,0,0,215,1,0,0,0,0,217,1,0,0,0,0,219,1,0,0,0,0,221,1, + 0,0,0,0,223,1,0,0,0,0,225,1,0,0,0,0,227,1,0,0,0,0,229,1,0,0,0,0, + 231,1,0,0,0,0,233,1,0,0,0,0,235,1,0,0,0,0,237,1,0,0,0,0,239,1,0, + 0,0,0,241,1,0,0,0,0,243,1,0,0,0,0,245,1,0,0,0,0,247,1,0,0,0,0,249, + 1,0,0,0,0,251,1,0,0,0,1,253,1,0,0,0,3,280,1,0,0,0,5,294,1,0,0,0, + 7,317,1,0,0,0,9,331,1,0,0,0,11,340,1,0,0,0,13,353,1,0,0,0,15,362, + 1,0,0,0,17,371,1,0,0,0,19,377,1,0,0,0,21,386,1,0,0,0,23,393,1,0, + 0,0,25,405,1,0,0,0,27,410,1,0,0,0,29,415,1,0,0,0,31,474,1,0,0,0, + 33,485,1,0,0,0,35,487,1,0,0,0,37,492,1,0,0,0,39,495,1,0,0,0,41,521, + 1,0,0,0,43,543,1,0,0,0,45,559,1,0,0,0,47,567,1,0,0,0,49,569,1,0, + 0,0,51,571,1,0,0,0,53,573,1,0,0,0,55,575,1,0,0,0,57,577,1,0,0,0, + 59,579,1,0,0,0,61,581,1,0,0,0,63,600,1,0,0,0,65,619,1,0,0,0,67,660, + 1,0,0,0,69,662,1,0,0,0,71,667,1,0,0,0,73,680,1,0,0,0,75,691,1,0, + 0,0,77,715,1,0,0,0,79,721,1,0,0,0,81,723,1,0,0,0,83,725,1,0,0,0, + 85,727,1,0,0,0,87,729,1,0,0,0,89,731,1,0,0,0,91,733,1,0,0,0,93,735, + 1,0,0,0,95,737,1,0,0,0,97,739,1,0,0,0,99,741,1,0,0,0,101,743,1,0, + 0,0,103,745,1,0,0,0,105,747,1,0,0,0,107,749,1,0,0,0,109,751,1,0, + 0,0,111,753,1,0,0,0,113,755,1,0,0,0,115,757,1,0,0,0,117,759,1,0, + 0,0,119,761,1,0,0,0,121,763,1,0,0,0,123,765,1,0,0,0,125,767,1,0, + 0,0,127,769,1,0,0,0,129,771,1,0,0,0,131,773,1,0,0,0,133,783,1,0, + 0,0,135,785,1,0,0,0,137,788,1,0,0,0,139,793,1,0,0,0,141,798,1,0, + 0,0,143,806,1,0,0,0,145,809,1,0,0,0,147,813,1,0,0,0,149,817,1,0, + 0,0,151,821,1,0,0,0,153,826,1,0,0,0,155,831,1,0,0,0,157,838,1,0, + 0,0,159,845,1,0,0,0,161,855,1,0,0,0,163,868,1,0,0,0,165,873,1,0, + 0,0,167,878,1,0,0,0,169,892,1,0,0,0,171,905,1,0,0,0,173,910,1,0, + 0,0,175,918,1,0,0,0,177,938,1,0,0,0,179,961,1,0,0,0,181,971,1,0, + 0,0,183,979,1,0,0,0,185,991,1,0,0,0,187,998,1,0,0,0,189,1006,1,0, + 0,0,191,1011,1,0,0,0,193,1015,1,0,0,0,195,1019,1,0,0,0,197,1022, + 1,0,0,0,199,1031,1,0,0,0,201,1036,1,0,0,0,203,1040,1,0,0,0,205,1045, + 1,0,0,0,207,1048,1,0,0,0,209,1053,1,0,0,0,211,1059,1,0,0,0,213,1064, + 1,0,0,0,215,1068,1,0,0,0,217,1072,1,0,0,0,219,1078,1,0,0,0,221,1084, + 1,0,0,0,223,1090,1,0,0,0,225,1095,1,0,0,0,227,1098,1,0,0,0,229,1105, + 1,0,0,0,231,1107,1,0,0,0,233,1109,1,0,0,0,235,1111,1,0,0,0,237,1113, + 1,0,0,0,239,1115,1,0,0,0,241,1117,1,0,0,0,243,1119,1,0,0,0,245,1121, + 1,0,0,0,247,1123,1,0,0,0,249,1125,1,0,0,0,251,1127,1,0,0,0,253,254, + 5,35,0,0,254,255,5,35,0,0,255,256,5,35,0,0,256,257,5,32,0,0,257, + 258,5,83,0,0,258,259,5,85,0,0,259,260,5,66,0,0,260,261,5,83,0,0, + 261,262,5,84,0,0,262,263,5,82,0,0,263,264,5,65,0,0,264,265,5,73, + 0,0,265,266,5,84,0,0,266,267,5,95,0,0,267,268,5,83,0,0,268,269,5, + 67,0,0,269,270,5,65,0,0,270,271,5,76,0,0,271,272,5,65,0,0,272,273, + 5,82,0,0,273,274,5,95,0,0,274,275,5,84,0,0,275,276,5,69,0,0,276, + 277,5,83,0,0,277,278,5,84,0,0,278,279,5,58,0,0,279,2,1,0,0,0,280, + 282,5,118,0,0,281,283,3,131,65,0,282,281,1,0,0,0,283,284,1,0,0,0, + 284,282,1,0,0,0,284,285,1,0,0,0,285,292,1,0,0,0,286,288,5,46,0,0, + 287,289,3,131,65,0,288,287,1,0,0,0,289,290,1,0,0,0,290,288,1,0,0, + 0,290,291,1,0,0,0,291,293,1,0,0,0,292,286,1,0,0,0,292,293,1,0,0, + 0,293,4,1,0,0,0,294,295,5,35,0,0,295,296,5,35,0,0,296,297,5,35,0, + 0,297,298,5,32,0,0,298,299,5,83,0,0,299,300,5,85,0,0,300,301,5,66, + 0,0,301,302,5,83,0,0,302,303,5,84,0,0,303,304,5,82,0,0,304,305,5, + 65,0,0,305,306,5,73,0,0,306,307,5,84,0,0,307,308,5,95,0,0,308,309, + 5,73,0,0,309,310,5,78,0,0,310,311,5,67,0,0,311,312,5,76,0,0,312, + 313,5,85,0,0,313,314,5,68,0,0,314,315,5,69,0,0,315,316,5,58,0,0, + 316,6,1,0,0,0,317,318,5,35,0,0,318,319,5,32,0,0,319,323,1,0,0,0, + 320,322,8,0,0,0,321,320,1,0,0,0,322,325,1,0,0,0,323,321,1,0,0,0, + 323,324,1,0,0,0,324,327,1,0,0,0,325,323,1,0,0,0,326,328,5,13,0,0, + 327,326,1,0,0,0,327,328,1,0,0,0,328,329,1,0,0,0,329,330,5,10,0,0, + 330,8,1,0,0,0,331,332,5,60,0,0,332,333,5,33,0,0,333,334,5,69,0,0, + 334,335,5,82,0,0,335,336,5,82,0,0,336,337,5,79,0,0,337,338,5,82, + 0,0,338,339,5,62,0,0,339,10,1,0,0,0,340,341,5,60,0,0,341,342,5,33, + 0,0,342,343,5,85,0,0,343,344,5,78,0,0,344,345,5,68,0,0,345,346,5, + 69,0,0,346,347,5,70,0,0,347,348,5,73,0,0,348,349,5,78,0,0,349,350, + 5,69,0,0,350,351,5,68,0,0,351,352,5,62,0,0,352,12,1,0,0,0,353,354, + 5,111,0,0,354,355,5,118,0,0,355,356,5,101,0,0,356,357,5,114,0,0, + 357,358,5,108,0,0,358,359,5,102,0,0,359,360,5,111,0,0,360,361,5, + 119,0,0,361,14,1,0,0,0,362,363,5,114,0,0,363,364,5,111,0,0,364,365, + 5,117,0,0,365,366,5,110,0,0,366,367,5,100,0,0,367,368,5,105,0,0, + 368,369,5,110,0,0,369,370,5,103,0,0,370,16,1,0,0,0,371,372,5,69, + 0,0,372,373,5,82,0,0,373,374,5,82,0,0,374,375,5,79,0,0,375,376,5, + 82,0,0,376,18,1,0,0,0,377,378,5,83,0,0,378,379,5,65,0,0,379,380, + 5,84,0,0,380,381,5,85,0,0,381,382,5,82,0,0,382,383,5,65,0,0,383, + 384,5,84,0,0,384,385,5,69,0,0,385,20,1,0,0,0,386,387,5,83,0,0,387, + 388,5,73,0,0,388,389,5,76,0,0,389,390,5,69,0,0,390,391,5,78,0,0, + 391,392,5,84,0,0,392,22,1,0,0,0,393,394,5,84,0,0,394,395,5,73,0, + 0,395,396,5,69,0,0,396,397,5,95,0,0,397,398,5,84,0,0,398,399,5,79, + 0,0,399,400,5,95,0,0,400,401,5,69,0,0,401,402,5,86,0,0,402,403,5, + 69,0,0,403,404,5,78,0,0,404,24,1,0,0,0,405,406,5,78,0,0,406,407, + 5,65,0,0,407,408,5,78,0,0,408,26,1,0,0,0,409,411,7,1,0,0,410,409, + 1,0,0,0,410,411,1,0,0,0,411,412,1,0,0,0,412,413,3,133,66,0,413,28, + 1,0,0,0,414,416,7,1,0,0,415,414,1,0,0,0,415,416,1,0,0,0,416,418, + 1,0,0,0,417,419,7,2,0,0,418,417,1,0,0,0,419,420,1,0,0,0,420,418, + 1,0,0,0,420,421,1,0,0,0,421,428,1,0,0,0,422,424,5,46,0,0,423,425, + 7,2,0,0,424,423,1,0,0,0,425,426,1,0,0,0,426,424,1,0,0,0,426,427, + 1,0,0,0,427,429,1,0,0,0,428,422,1,0,0,0,428,429,1,0,0,0,429,30,1, + 0,0,0,430,432,7,1,0,0,431,430,1,0,0,0,431,432,1,0,0,0,432,434,1, + 0,0,0,433,435,7,2,0,0,434,433,1,0,0,0,435,436,1,0,0,0,436,434,1, + 0,0,0,436,437,1,0,0,0,437,445,1,0,0,0,438,442,5,46,0,0,439,441,7, + 2,0,0,440,439,1,0,0,0,441,444,1,0,0,0,442,440,1,0,0,0,442,443,1, + 0,0,0,443,446,1,0,0,0,444,442,1,0,0,0,445,438,1,0,0,0,445,446,1, + 0,0,0,446,456,1,0,0,0,447,449,7,3,0,0,448,450,7,1,0,0,449,448,1, + 0,0,0,449,450,1,0,0,0,450,452,1,0,0,0,451,453,7,2,0,0,452,451,1, + 0,0,0,453,454,1,0,0,0,454,452,1,0,0,0,454,455,1,0,0,0,455,457,1, + 0,0,0,456,447,1,0,0,0,456,457,1,0,0,0,457,475,1,0,0,0,458,460,7, + 1,0,0,459,458,1,0,0,0,459,460,1,0,0,0,460,461,1,0,0,0,461,462,5, + 105,0,0,462,463,5,110,0,0,463,475,5,102,0,0,464,465,5,110,0,0,465, + 466,5,97,0,0,466,475,5,110,0,0,467,468,5,78,0,0,468,469,5,97,0,0, + 469,475,5,78,0,0,470,471,5,115,0,0,471,472,5,110,0,0,472,473,5,97, + 0,0,473,475,5,110,0,0,474,431,1,0,0,0,474,459,1,0,0,0,474,464,1, + 0,0,0,474,467,1,0,0,0,474,470,1,0,0,0,475,32,1,0,0,0,476,477,5,116, + 0,0,477,478,5,114,0,0,478,479,5,117,0,0,479,486,5,101,0,0,480,481, + 5,102,0,0,481,482,5,97,0,0,482,483,5,108,0,0,483,484,5,115,0,0,484, + 486,5,101,0,0,485,476,1,0,0,0,485,480,1,0,0,0,486,34,1,0,0,0,487, + 488,7,2,0,0,488,489,7,2,0,0,489,490,7,2,0,0,490,491,7,2,0,0,491, + 36,1,0,0,0,492,493,7,2,0,0,493,494,7,2,0,0,494,38,1,0,0,0,495,496, + 5,39,0,0,496,497,3,35,17,0,497,498,5,45,0,0,498,499,3,37,18,0,499, + 500,5,45,0,0,500,501,3,37,18,0,501,502,5,84,0,0,502,503,3,37,18, + 0,503,504,5,58,0,0,504,505,3,37,18,0,505,506,5,58,0,0,506,513,3, + 37,18,0,507,509,5,46,0,0,508,510,7,2,0,0,509,508,1,0,0,0,510,511, + 1,0,0,0,511,509,1,0,0,0,511,512,1,0,0,0,512,514,1,0,0,0,513,507, + 1,0,0,0,513,514,1,0,0,0,514,515,1,0,0,0,515,516,7,1,0,0,516,517, + 3,37,18,0,517,518,5,58,0,0,518,519,3,37,18,0,519,520,5,39,0,0,520, + 40,1,0,0,0,521,522,5,39,0,0,522,523,3,35,17,0,523,524,5,45,0,0,524, + 525,3,37,18,0,525,526,5,45,0,0,526,527,3,37,18,0,527,528,5,84,0, + 0,528,529,3,37,18,0,529,530,5,58,0,0,530,531,3,37,18,0,531,532,5, + 58,0,0,532,539,3,37,18,0,533,535,5,46,0,0,534,536,7,2,0,0,535,534, + 1,0,0,0,536,537,1,0,0,0,537,535,1,0,0,0,537,538,1,0,0,0,538,540, + 1,0,0,0,539,533,1,0,0,0,539,540,1,0,0,0,540,541,1,0,0,0,541,542, + 5,39,0,0,542,42,1,0,0,0,543,544,5,39,0,0,544,545,3,37,18,0,545,546, + 5,58,0,0,546,547,3,37,18,0,547,548,5,58,0,0,548,555,3,37,18,0,549, + 551,5,46,0,0,550,552,7,2,0,0,551,550,1,0,0,0,552,553,1,0,0,0,553, + 551,1,0,0,0,553,554,1,0,0,0,554,556,1,0,0,0,555,549,1,0,0,0,555, + 556,1,0,0,0,556,557,1,0,0,0,557,558,5,39,0,0,558,44,1,0,0,0,559, + 560,5,39,0,0,560,561,3,35,17,0,561,562,5,45,0,0,562,563,3,37,18, + 0,563,564,5,45,0,0,564,565,3,37,18,0,565,566,5,39,0,0,566,46,1,0, + 0,0,567,568,5,80,0,0,568,48,1,0,0,0,569,570,5,84,0,0,570,50,1,0, + 0,0,571,572,5,89,0,0,572,52,1,0,0,0,573,574,5,77,0,0,574,54,1,0, + 0,0,575,576,5,68,0,0,576,56,1,0,0,0,577,578,5,72,0,0,578,58,1,0, + 0,0,579,580,5,83,0,0,580,60,1,0,0,0,581,582,5,70,0,0,582,62,1,0, + 0,0,583,584,5,39,0,0,584,585,3,47,23,0,585,586,3,27,13,0,586,590, + 3,51,25,0,587,588,3,27,13,0,588,589,3,53,26,0,589,591,1,0,0,0,590, + 587,1,0,0,0,590,591,1,0,0,0,591,592,1,0,0,0,592,593,5,39,0,0,593, + 601,1,0,0,0,594,595,5,39,0,0,595,596,3,47,23,0,596,597,3,27,13,0, + 597,598,3,53,26,0,598,599,5,39,0,0,599,601,1,0,0,0,600,583,1,0,0, + 0,600,594,1,0,0,0,601,64,1,0,0,0,602,603,5,39,0,0,603,604,3,47,23, + 0,604,605,3,27,13,0,605,609,3,55,27,0,606,607,3,49,24,0,607,608, + 3,67,33,0,608,610,1,0,0,0,609,606,1,0,0,0,609,610,1,0,0,0,610,611, + 1,0,0,0,611,612,5,39,0,0,612,620,1,0,0,0,613,614,5,39,0,0,614,615, + 3,47,23,0,615,616,3,49,24,0,616,617,3,67,33,0,617,618,5,39,0,0,618, + 620,1,0,0,0,619,602,1,0,0,0,619,613,1,0,0,0,620,66,1,0,0,0,621,622, + 3,27,13,0,622,626,3,57,28,0,623,624,3,27,13,0,624,625,3,53,26,0, + 625,627,1,0,0,0,626,623,1,0,0,0,626,627,1,0,0,0,627,631,1,0,0,0, + 628,629,3,27,13,0,629,630,3,59,29,0,630,632,1,0,0,0,631,628,1,0, + 0,0,631,632,1,0,0,0,632,636,1,0,0,0,633,634,3,27,13,0,634,635,3, + 61,30,0,635,637,1,0,0,0,636,633,1,0,0,0,636,637,1,0,0,0,637,661, + 1,0,0,0,638,639,3,27,13,0,639,643,3,53,26,0,640,641,3,27,13,0,641, + 642,3,59,29,0,642,644,1,0,0,0,643,640,1,0,0,0,643,644,1,0,0,0,644, + 648,1,0,0,0,645,646,3,27,13,0,646,647,3,61,30,0,647,649,1,0,0,0, + 648,645,1,0,0,0,648,649,1,0,0,0,649,661,1,0,0,0,650,651,3,27,13, + 0,651,655,3,59,29,0,652,653,3,27,13,0,653,654,3,61,30,0,654,656, + 1,0,0,0,655,652,1,0,0,0,655,656,1,0,0,0,656,661,1,0,0,0,657,658, + 3,27,13,0,658,659,3,61,30,0,659,661,1,0,0,0,660,621,1,0,0,0,660, + 638,1,0,0,0,660,650,1,0,0,0,660,657,1,0,0,0,661,68,1,0,0,0,662,663, + 5,110,0,0,663,664,5,117,0,0,664,665,5,108,0,0,665,666,5,108,0,0, + 666,70,1,0,0,0,667,675,5,39,0,0,668,669,5,92,0,0,669,674,9,0,0,0, + 670,671,5,39,0,0,671,674,5,39,0,0,672,674,8,4,0,0,673,668,1,0,0, + 0,673,670,1,0,0,0,673,672,1,0,0,0,674,677,1,0,0,0,675,673,1,0,0, + 0,675,676,1,0,0,0,676,678,1,0,0,0,677,675,1,0,0,0,678,679,5,39,0, + 0,679,72,1,0,0,0,680,681,5,47,0,0,681,682,5,47,0,0,682,686,1,0,0, + 0,683,685,8,0,0,0,684,683,1,0,0,0,685,688,1,0,0,0,686,684,1,0,0, + 0,686,687,1,0,0,0,687,689,1,0,0,0,688,686,1,0,0,0,689,690,6,36,0, + 0,690,74,1,0,0,0,691,692,5,47,0,0,692,693,5,42,0,0,693,701,1,0,0, + 0,694,702,8,5,0,0,695,697,5,42,0,0,696,695,1,0,0,0,697,698,1,0,0, + 0,698,696,1,0,0,0,698,699,1,0,0,0,699,700,1,0,0,0,700,702,8,6,0, + 0,701,694,1,0,0,0,701,696,1,0,0,0,702,706,1,0,0,0,703,705,5,42,0, + 0,704,703,1,0,0,0,705,708,1,0,0,0,706,704,1,0,0,0,706,707,1,0,0, + 0,707,709,1,0,0,0,708,706,1,0,0,0,709,710,5,42,0,0,710,711,5,47, + 0,0,711,712,1,0,0,0,712,713,6,37,0,0,713,76,1,0,0,0,714,716,7,7, + 0,0,715,714,1,0,0,0,716,717,1,0,0,0,717,715,1,0,0,0,717,718,1,0, + 0,0,718,719,1,0,0,0,719,720,6,38,0,0,720,78,1,0,0,0,721,722,7,8, + 0,0,722,80,1,0,0,0,723,724,7,9,0,0,724,82,1,0,0,0,725,726,7,10,0, + 0,726,84,1,0,0,0,727,728,7,11,0,0,728,86,1,0,0,0,729,730,7,3,0,0, + 730,88,1,0,0,0,731,732,7,12,0,0,732,90,1,0,0,0,733,734,7,13,0,0, + 734,92,1,0,0,0,735,736,7,14,0,0,736,94,1,0,0,0,737,738,7,15,0,0, + 738,96,1,0,0,0,739,740,7,16,0,0,740,98,1,0,0,0,741,742,7,17,0,0, + 742,100,1,0,0,0,743,744,7,18,0,0,744,102,1,0,0,0,745,746,7,19,0, + 0,746,104,1,0,0,0,747,748,7,20,0,0,748,106,1,0,0,0,749,750,7,21, + 0,0,750,108,1,0,0,0,751,752,7,22,0,0,752,110,1,0,0,0,753,754,7,23, + 0,0,754,112,1,0,0,0,755,756,7,24,0,0,756,114,1,0,0,0,757,758,7,25, + 0,0,758,116,1,0,0,0,759,760,7,26,0,0,760,118,1,0,0,0,761,762,7,27, + 0,0,762,120,1,0,0,0,763,764,7,28,0,0,764,122,1,0,0,0,765,766,7,29, + 0,0,766,124,1,0,0,0,767,768,7,30,0,0,768,126,1,0,0,0,769,770,7,31, + 0,0,770,128,1,0,0,0,771,772,7,32,0,0,772,130,1,0,0,0,773,774,7,2, + 0,0,774,132,1,0,0,0,775,784,5,48,0,0,776,780,7,33,0,0,777,779,7, + 2,0,0,778,777,1,0,0,0,779,782,1,0,0,0,780,778,1,0,0,0,780,781,1, + 0,0,0,781,784,1,0,0,0,782,780,1,0,0,0,783,775,1,0,0,0,783,776,1, + 0,0,0,784,134,1,0,0,0,785,786,3,95,47,0,786,787,3,89,44,0,787,136, + 1,0,0,0,788,789,3,117,58,0,789,790,3,93,46,0,790,791,3,87,43,0,791, + 792,3,105,52,0,792,138,1,0,0,0,793,794,3,87,43,0,794,795,3,101,50, + 0,795,796,3,115,57,0,796,797,3,87,43,0,797,140,1,0,0,0,798,799,3, + 81,40,0,799,800,3,107,53,0,800,801,3,107,53,0,801,802,3,101,50,0, + 802,803,3,87,43,0,803,804,3,79,39,0,804,805,3,105,52,0,805,142,1, + 0,0,0,806,807,3,95,47,0,807,808,5,56,0,0,808,144,1,0,0,0,809,810, + 3,95,47,0,810,811,5,49,0,0,811,812,5,54,0,0,812,146,1,0,0,0,813, + 814,3,95,47,0,814,815,5,51,0,0,815,816,5,50,0,0,816,148,1,0,0,0, + 817,818,3,95,47,0,818,819,5,54,0,0,819,820,5,52,0,0,820,150,1,0, + 0,0,821,822,3,89,44,0,822,823,3,109,54,0,823,824,5,51,0,0,824,825, + 5,50,0,0,825,152,1,0,0,0,826,827,3,89,44,0,827,828,3,109,54,0,828, + 829,5,54,0,0,829,830,5,52,0,0,830,154,1,0,0,0,831,832,3,115,57,0, + 832,833,3,117,58,0,833,834,3,113,56,0,834,835,3,95,47,0,835,836, + 3,105,52,0,836,837,3,91,45,0,837,156,1,0,0,0,838,839,3,81,40,0,839, + 840,3,95,47,0,840,841,3,105,52,0,841,842,3,79,39,0,842,843,3,113, + 56,0,843,844,3,127,63,0,844,158,1,0,0,0,845,846,3,117,58,0,846,847, + 3,95,47,0,847,848,3,103,51,0,848,849,3,87,43,0,849,850,3,115,57, + 0,850,851,3,117,58,0,851,852,3,79,39,0,852,853,3,103,51,0,853,854, + 3,109,54,0,854,160,1,0,0,0,855,856,3,117,58,0,856,857,3,95,47,0, + 857,858,3,103,51,0,858,859,3,87,43,0,859,860,3,115,57,0,860,861, + 3,117,58,0,861,862,3,79,39,0,862,863,3,103,51,0,863,864,3,109,54, + 0,864,865,5,95,0,0,865,866,3,117,58,0,866,867,3,129,64,0,867,162, + 1,0,0,0,868,869,3,85,42,0,869,870,3,79,39,0,870,871,3,117,58,0,871, + 872,3,87,43,0,872,164,1,0,0,0,873,874,3,117,58,0,874,875,3,95,47, + 0,875,876,3,103,51,0,876,877,3,87,43,0,877,166,1,0,0,0,878,879,3, + 95,47,0,879,880,3,105,52,0,880,881,3,117,58,0,881,882,3,87,43,0, + 882,883,3,113,56,0,883,884,3,121,60,0,884,885,3,79,39,0,885,886, + 3,101,50,0,886,887,5,95,0,0,887,888,3,127,63,0,888,889,3,87,43,0, + 889,890,3,79,39,0,890,891,3,113,56,0,891,168,1,0,0,0,892,893,3,95, + 47,0,893,894,3,105,52,0,894,895,3,117,58,0,895,896,3,87,43,0,896, + 897,3,113,56,0,897,898,3,121,60,0,898,899,3,79,39,0,899,900,3,101, + 50,0,900,901,5,95,0,0,901,902,3,85,42,0,902,903,3,79,39,0,903,904, + 3,127,63,0,904,170,1,0,0,0,905,906,3,119,59,0,906,907,3,119,59,0, + 907,908,3,95,47,0,908,909,3,85,42,0,909,172,1,0,0,0,910,911,3,85, + 42,0,911,912,3,87,43,0,912,913,3,83,41,0,913,914,3,95,47,0,914,915, + 3,103,51,0,915,916,3,79,39,0,916,917,3,101,50,0,917,174,1,0,0,0, + 918,919,3,109,54,0,919,920,3,113,56,0,920,921,3,87,43,0,921,922, + 3,83,41,0,922,923,3,95,47,0,923,924,3,115,57,0,924,925,3,95,47,0, + 925,926,3,107,53,0,926,927,3,105,52,0,927,928,5,95,0,0,928,929,3, + 117,58,0,929,930,3,95,47,0,930,931,3,103,51,0,931,932,3,87,43,0, + 932,933,3,115,57,0,933,934,3,117,58,0,934,935,3,79,39,0,935,936, + 3,103,51,0,936,937,3,109,54,0,937,176,1,0,0,0,938,939,3,109,54,0, + 939,940,3,113,56,0,940,941,3,87,43,0,941,942,3,83,41,0,942,943,3, + 95,47,0,943,944,3,115,57,0,944,945,3,95,47,0,945,946,3,107,53,0, + 946,947,3,105,52,0,947,948,5,95,0,0,948,949,3,117,58,0,949,950,3, + 95,47,0,950,951,3,103,51,0,951,952,3,87,43,0,952,953,3,115,57,0, + 953,954,3,117,58,0,954,955,3,79,39,0,955,956,3,103,51,0,956,957, + 3,109,54,0,957,958,5,95,0,0,958,959,3,117,58,0,959,960,3,129,64, + 0,960,178,1,0,0,0,961,962,3,89,44,0,962,963,3,95,47,0,963,964,3, + 125,62,0,964,965,3,87,43,0,965,966,3,85,42,0,966,967,3,83,41,0,967, + 968,3,93,46,0,968,969,3,79,39,0,969,970,3,113,56,0,970,180,1,0,0, + 0,971,972,3,121,60,0,972,973,3,79,39,0,973,974,3,113,56,0,974,975, + 3,83,41,0,975,976,3,93,46,0,976,977,3,79,39,0,977,978,3,113,56,0, + 978,182,1,0,0,0,979,980,3,89,44,0,980,981,3,95,47,0,981,982,3,125, + 62,0,982,983,3,87,43,0,983,984,3,85,42,0,984,985,3,81,40,0,985,986, + 3,95,47,0,986,987,3,105,52,0,987,988,3,79,39,0,988,989,3,113,56, + 0,989,990,3,127,63,0,990,184,1,0,0,0,991,992,3,115,57,0,992,993, + 3,117,58,0,993,994,3,113,56,0,994,995,3,119,59,0,995,996,3,83,41, + 0,996,997,3,117,58,0,997,186,1,0,0,0,998,999,3,105,52,0,999,1000, + 3,115,57,0,1000,1001,3,117,58,0,1001,1002,3,113,56,0,1002,1003,3, + 119,59,0,1003,1004,3,83,41,0,1004,1005,3,117,58,0,1005,188,1,0,0, + 0,1006,1007,3,101,50,0,1007,1008,3,95,47,0,1008,1009,3,115,57,0, + 1009,1010,3,117,58,0,1010,190,1,0,0,0,1011,1012,3,103,51,0,1012, + 1013,3,79,39,0,1013,1014,3,109,54,0,1014,192,1,0,0,0,1015,1016,3, + 79,39,0,1016,1017,3,105,52,0,1017,1018,3,127,63,0,1018,194,1,0,0, + 0,1019,1020,3,119,59,0,1020,1021,5,33,0,0,1021,196,1,0,0,0,1022, + 1023,3,91,45,0,1023,1024,3,87,43,0,1024,1025,3,107,53,0,1025,1026, + 3,103,51,0,1026,1027,3,87,43,0,1027,1028,3,117,58,0,1028,1029,3, + 113,56,0,1029,1030,3,127,63,0,1030,198,1,0,0,0,1031,1032,3,81,40, + 0,1032,1033,3,107,53,0,1033,1034,3,107,53,0,1034,1035,3,101,50,0, + 1035,200,1,0,0,0,1036,1037,3,115,57,0,1037,1038,3,117,58,0,1038, + 1039,3,113,56,0,1039,202,1,0,0,0,1040,1041,3,121,60,0,1041,1042, + 3,81,40,0,1042,1043,3,95,47,0,1043,1044,3,105,52,0,1044,204,1,0, + 0,0,1045,1046,3,117,58,0,1046,1047,3,115,57,0,1047,206,1,0,0,0,1048, + 1049,3,117,58,0,1049,1050,3,115,57,0,1050,1051,3,117,58,0,1051,1052, + 3,129,64,0,1052,208,1,0,0,0,1053,1054,3,95,47,0,1054,1055,3,127, + 63,0,1055,1056,3,87,43,0,1056,1057,3,79,39,0,1057,1058,3,113,56, + 0,1058,210,1,0,0,0,1059,1060,3,95,47,0,1060,1061,3,85,42,0,1061, + 1062,3,79,39,0,1062,1063,3,127,63,0,1063,212,1,0,0,0,1064,1065,3, + 85,42,0,1065,1066,3,87,43,0,1066,1067,3,83,41,0,1067,214,1,0,0,0, + 1068,1069,3,109,54,0,1069,1070,3,117,58,0,1070,1071,3,115,57,0,1071, + 216,1,0,0,0,1072,1073,3,109,54,0,1073,1074,3,117,58,0,1074,1075, + 3,115,57,0,1075,1076,3,117,58,0,1076,1077,3,129,64,0,1077,218,1, + 0,0,0,1078,1079,3,89,44,0,1079,1080,3,83,41,0,1080,1081,3,93,46, + 0,1081,1082,3,79,39,0,1082,1083,3,113,56,0,1083,220,1,0,0,0,1084, + 1085,3,121,60,0,1085,1086,3,83,41,0,1086,1087,3,93,46,0,1087,1088, + 3,79,39,0,1088,1089,3,113,56,0,1089,222,1,0,0,0,1090,1091,3,89,44, + 0,1091,1092,3,81,40,0,1092,1093,3,95,47,0,1093,1094,3,105,52,0,1094, + 224,1,0,0,0,1095,1096,5,58,0,0,1096,1097,5,58,0,0,1097,226,1,0,0, + 0,1098,1102,7,34,0,0,1099,1101,7,35,0,0,1100,1099,1,0,0,0,1101,1104, + 1,0,0,0,1102,1100,1,0,0,0,1102,1103,1,0,0,0,1103,228,1,0,0,0,1104, + 1102,1,0,0,0,1105,1106,5,60,0,0,1106,230,1,0,0,0,1107,1108,5,62, + 0,0,1108,232,1,0,0,0,1109,1110,5,40,0,0,1110,234,1,0,0,0,1111,1112, + 5,41,0,0,1112,236,1,0,0,0,1113,1114,5,91,0,0,1114,238,1,0,0,0,1115, + 1116,5,93,0,0,1116,240,1,0,0,0,1117,1118,5,44,0,0,1118,242,1,0,0, + 0,1119,1120,5,61,0,0,1120,244,1,0,0,0,1121,1122,5,58,0,0,1122,246, + 1,0,0,0,1123,1124,5,63,0,0,1124,248,1,0,0,0,1125,1126,5,35,0,0,1126, + 250,1,0,0,0,1127,1128,5,46,0,0,1128,252,1,0,0,0,48,0,284,290,292, + 323,327,410,415,420,426,428,431,436,442,445,449,454,456,459,474, + 485,511,513,537,539,553,555,590,600,609,619,626,631,636,643,648, + 655,660,673,675,686,698,701,706,717,780,783,1102,1,0,1,0 + ] + +class FuncTestCaseLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + SUBSTRAIT_SCALAR_TEST = 1 + FORMAT_VERSION = 2 + SUBSTRAIT_INCLUDE = 3 + DESCRIPTION_LINE = 4 + ERROR_RESULT = 5 + UNDEFINED_RESULT = 6 + OVERFLOW = 7 + ROUNDING = 8 + ERROR = 9 + SATURATE = 10 + SILENT = 11 + TIE_TO_EVEN = 12 + NAN = 13 + INTEGER_LITERAL = 14 + DECIMAL_LITERAL = 15 + FLOAT_LITERAL = 16 + BOOLEAN_LITERAL = 17 + TIMESTAMP_TZ_LITERAL = 18 + TIMESTAMP_LITERAL = 19 + TIME_LITERAL = 20 + DATE_LITERAL = 21 + PERIOD_PREFIX = 22 + TIME_PREFIX = 23 + YEAR_SUFFIX = 24 + M_SUFFIX = 25 + DAY_SUFFIX = 26 + HOUR_SUFFIX = 27 + SECOND_SUFFIX = 28 + FRACTIONAL_SECOND_SUFFIX = 29 + INTERVAL_YEAR_LITERAL = 30 + INTERVAL_DAY_LITERAL = 31 + NULL_LITERAL = 32 + STRING_LITERAL = 33 + LineComment = 34 + BlockComment = 35 + Whitespace = 36 + If = 37 + Then = 38 + Else = 39 + Boolean = 40 + I8 = 41 + I16 = 42 + I32 = 43 + I64 = 44 + FP32 = 45 + FP64 = 46 + String = 47 + Binary = 48 + Timestamp = 49 + Timestamp_TZ = 50 + Date = 51 + Time = 52 + Interval_Year = 53 + Interval_Day = 54 + UUID = 55 + Decimal = 56 + Precision_Timestamp = 57 + Precision_Timestamp_TZ = 58 + FixedChar = 59 + VarChar = 60 + FixedBinary = 61 + Struct = 62 + NStruct = 63 + List = 64 + Map = 65 + ANY = 66 + UserDefined = 67 + Geometry = 68 + Bool = 69 + Str = 70 + VBin = 71 + Ts = 72 + TsTZ = 73 + IYear = 74 + IDay = 75 + Dec = 76 + PTs = 77 + PTsTZ = 78 + FChar = 79 + VChar = 80 + FBin = 81 + DOUBLE_COLON = 82 + IDENTIFIER = 83 + O_ANGLE_BRACKET = 84 + C_ANGLE_BRACKET = 85 + OPAREN = 86 + CPAREN = 87 + OBRACKET = 88 + CBRACKET = 89 + COMMA = 90 + EQ = 91 + COLON = 92 + QMARK = 93 + HASH = 94 + DOT = 95 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE" ] + + literalNames = [ "", + "'### SUBSTRAIT_SCALAR_TEST:'", "'### SUBSTRAIT_INCLUDE:'", + "''", "''", "'overlfow'", "'rounding'", + "'ERROR'", "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", + "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", "'null'", + "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", + "':'", "'?'", "'#'", "'.'" ] + + symbolicNames = [ "", + "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", "OVERFLOW", + "ROUNDING", "ERROR", "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", + "INTEGER_LITERAL", "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", + "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", + "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", "NULL_LITERAL", + "STRING_LITERAL", "LineComment", "BlockComment", "Whitespace", + "If", "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", + "FP32", "FP64", "String", "Binary", "Timestamp", "Timestamp_TZ", + "Date", "Time", "Interval_Year", "Interval_Day", "UUID", "Decimal", + "Precision_Timestamp", "Precision_Timestamp_TZ", "FixedChar", + "VarChar", "FixedBinary", "Struct", "NStruct", "List", "Map", + "ANY", "UserDefined", "Geometry", "Bool", "Str", "VBin", "Ts", + "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", "FChar", "VChar", + "FBin", "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", + "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", + "QMARK", "HASH", "DOT" ] + + ruleNames = [ "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", + "OVERFLOW", "ROUNDING", "ERROR", "SATURATE", "SILENT", + "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", "DECIMAL_LITERAL", + "FLOAT_LITERAL", "BOOLEAN_LITERAL", "FourDigits", "TwoDigits", + "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", + "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", + "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", + "TIME_INTERVAL", "NULL_LITERAL", "STRING_LITERAL", "LineComment", + "BlockComment", "Whitespace", "A", "B", "C", "D", "E", + "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", + "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "DIGIT", + "INTEGER", "If", "Then", "Else", "Boolean", "I8", "I16", + "I32", "I64", "FP32", "FP64", "String", "Binary", "Timestamp", + "Timestamp_TZ", "Date", "Time", "Interval_Year", "Interval_Day", + "UUID", "Decimal", "Precision_Timestamp", "Precision_Timestamp_TZ", + "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", + "List", "Map", "ANY", "UserDefined", "Geometry", "Bool", + "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", + "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", + "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", "CPAREN", + "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", "QMARK", + "HASH", "DOT" ] + + grammarFileName = "FuncTestCaseLexer.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/tests/coverage/antlr_parser/TestFileLexer.tokens b/tests/coverage/antlr_parser/FuncTestCaseLexer.tokens similarity index 69% rename from tests/coverage/antlr_parser/TestFileLexer.tokens rename to tests/coverage/antlr_parser/FuncTestCaseLexer.tokens index a3b65b74e..ccc9fabc8 100644 --- a/tests/coverage/antlr_parser/TestFileLexer.tokens +++ b/tests/coverage/antlr_parser/FuncTestCaseLexer.tokens @@ -47,15 +47,15 @@ FP64=46 String=47 Binary=48 Timestamp=49 -TimestampTZ=50 +Timestamp_TZ=50 Date=51 Time=52 -IntervalYear=53 -IntervalDay=54 +Interval_Year=53 +Interval_Day=54 UUID=55 Decimal=56 -PrecisionTimestamp=57 -PrecisionTimestampTZ=58 +Precision_Timestamp=57 +Precision_Timestamp_TZ=58 FixedChar=59 VarChar=60 FixedBinary=61 @@ -65,33 +65,34 @@ List=64 Map=65 ANY=66 UserDefined=67 -Bool=68 -Str=69 -VBin=70 -Ts=71 -TsTZ=72 -IYear=73 -IDay=74 -Dec=75 -PTs=76 -PTsTZ=77 -FChar=78 -VChar=79 -FBin=80 -DOUBLE_COLON=81 -IDENTIFIER=82 -O_ANGLE_BRACKET=83 -C_ANGLE_BRACKET=84 -OPAREN=85 -CPAREN=86 -OBRACKET=87 -CBRACKET=88 -COMMA=89 -EQ=90 -COLON=91 -QMARK=92 -HASH=93 -DOT=94 +Geometry=68 +Bool=69 +Str=70 +VBin=71 +Ts=72 +TsTZ=73 +IYear=74 +IDay=75 +Dec=76 +PTs=77 +PTsTZ=78 +FChar=79 +VChar=80 +FBin=81 +DOUBLE_COLON=82 +IDENTIFIER=83 +O_ANGLE_BRACKET=84 +C_ANGLE_BRACKET=85 +OPAREN=86 +CPAREN=87 +OBRACKET=88 +CBRACKET=89 +COMMA=90 +EQ=91 +COLON=92 +QMARK=93 +HASH=94 +DOT=95 '### SUBSTRAIT_SCALAR_TEST:'=1 '### SUBSTRAIT_INCLUDE:'=3 ''=5 @@ -112,16 +113,16 @@ DOT=94 'S'=28 'F'=29 'null'=32 -'::'=81 -'<'=83 -'>'=84 -'('=85 -')'=86 -'['=87 -']'=88 -','=89 -'='=90 -':'=91 -'?'=92 -'#'=93 -'.'=94 +'::'=82 +'<'=84 +'>'=85 +'('=86 +')'=87 +'['=88 +']'=89 +','=90 +'='=91 +':'=92 +'?'=93 +'#'=94 +'.'=95 diff --git a/tests/coverage/antlr_parser/TestFileParser.interp b/tests/coverage/antlr_parser/FuncTestCaseParser.interp similarity index 76% rename from tests/coverage/antlr_parser/TestFileParser.interp rename to tests/coverage/antlr_parser/FuncTestCaseParser.interp index 9933e9abe..71841dc57 100644 --- a/tests/coverage/antlr_parser/TestFileParser.interp +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.interp @@ -80,6 +80,7 @@ null null null null +null '::' null '<' @@ -146,15 +147,15 @@ FP64 String Binary Timestamp -TimestampTZ +Timestamp_TZ Date Time -IntervalYear -IntervalDay +Interval_Year +Interval_Day UUID Decimal -PrecisionTimestamp -PrecisionTimestampTZ +Precision_Timestamp +Precision_Timestamp_TZ FixedChar VarChar FixedBinary @@ -164,6 +165,7 @@ List Map ANY UserDefined +Geometry Bool Str VBin @@ -241,4 +243,4 @@ func_options atn: -[4, 1, 94, 395, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 1, 0, 1, 0, 4, 0, 93, 8, 0, 11, 0, 12, 0, 94, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 109, 8, 3, 10, 3, 12, 3, 112, 9, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 124, 8, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 4, 6, 131, 8, 6, 11, 6, 12, 6, 132, 1, 7, 1, 7, 1, 7, 5, 7, 138, 8, 7, 10, 7, 12, 7, 141, 9, 7, 1, 8, 1, 8, 3, 8, 145, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 163, 8, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 237, 8, 27, 1, 27, 1, 27, 1, 27, 3, 27, 242, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 250, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 255, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 261, 8, 29, 1, 29, 1, 29, 3, 29, 265, 8, 29, 1, 29, 1, 29, 3, 29, 269, 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 275, 8, 29, 1, 29, 1, 29, 3, 29, 279, 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 285, 8, 29, 1, 29, 1, 29, 3, 29, 289, 8, 29, 1, 30, 1, 30, 3, 30, 293, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 313, 8, 31, 1, 32, 1, 32, 3, 32, 317, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 3, 33, 325, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 3, 34, 333, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 3, 35, 341, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 349, 8, 35, 1, 36, 1, 36, 3, 36, 353, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 3, 37, 361, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 373, 8, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 5, 44, 390, 8, 44, 10, 44, 12, 44, 393, 9, 44, 1, 44, 0, 0, 45, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 0, 4, 1, 0, 14, 16, 1, 0, 5, 6, 2, 0, 7, 8, 82, 82, 1, 0, 9, 13, 413, 0, 90, 1, 0, 0, 0, 2, 98, 1, 0, 0, 0, 4, 101, 1, 0, 0, 0, 6, 104, 1, 0, 0, 0, 8, 113, 1, 0, 0, 0, 10, 115, 1, 0, 0, 0, 12, 128, 1, 0, 0, 0, 14, 134, 1, 0, 0, 0, 16, 144, 1, 0, 0, 0, 18, 162, 1, 0, 0, 0, 20, 164, 1, 0, 0, 0, 22, 166, 1, 0, 0, 0, 24, 170, 1, 0, 0, 0, 26, 174, 1, 0, 0, 0, 28, 178, 1, 0, 0, 0, 30, 182, 1, 0, 0, 0, 32, 186, 1, 0, 0, 0, 34, 190, 1, 0, 0, 0, 36, 194, 1, 0, 0, 0, 38, 198, 1, 0, 0, 0, 40, 202, 1, 0, 0, 0, 42, 206, 1, 0, 0, 0, 44, 210, 1, 0, 0, 0, 46, 214, 1, 0, 0, 0, 48, 218, 1, 0, 0, 0, 50, 222, 1, 0, 0, 0, 52, 226, 1, 0, 0, 0, 54, 241, 1, 0, 0, 0, 56, 254, 1, 0, 0, 0, 58, 288, 1, 0, 0, 0, 60, 292, 1, 0, 0, 0, 62, 312, 1, 0, 0, 0, 64, 314, 1, 0, 0, 0, 66, 322, 1, 0, 0, 0, 68, 330, 1, 0, 0, 0, 70, 338, 1, 0, 0, 0, 72, 350, 1, 0, 0, 0, 74, 358, 1, 0, 0, 0, 76, 372, 1, 0, 0, 0, 78, 374, 1, 0, 0, 0, 80, 376, 1, 0, 0, 0, 82, 378, 1, 0, 0, 0, 84, 382, 1, 0, 0, 0, 86, 384, 1, 0, 0, 0, 88, 386, 1, 0, 0, 0, 90, 92, 3, 2, 1, 0, 91, 93, 3, 12, 6, 0, 92, 91, 1, 0, 0, 0, 93, 94, 1, 0, 0, 0, 94, 92, 1, 0, 0, 0, 94, 95, 1, 0, 0, 0, 95, 96, 1, 0, 0, 0, 96, 97, 5, 0, 0, 1, 97, 1, 1, 0, 0, 0, 98, 99, 3, 4, 2, 0, 99, 100, 3, 6, 3, 0, 100, 3, 1, 0, 0, 0, 101, 102, 5, 1, 0, 0, 102, 103, 5, 2, 0, 0, 103, 5, 1, 0, 0, 0, 104, 105, 5, 3, 0, 0, 105, 110, 5, 33, 0, 0, 106, 107, 5, 89, 0, 0, 107, 109, 5, 33, 0, 0, 108, 106, 1, 0, 0, 0, 109, 112, 1, 0, 0, 0, 110, 108, 1, 0, 0, 0, 110, 111, 1, 0, 0, 0, 111, 7, 1, 0, 0, 0, 112, 110, 1, 0, 0, 0, 113, 114, 5, 4, 0, 0, 114, 9, 1, 0, 0, 0, 115, 116, 5, 82, 0, 0, 116, 117, 5, 85, 0, 0, 117, 118, 3, 14, 7, 0, 118, 123, 5, 86, 0, 0, 119, 120, 5, 87, 0, 0, 120, 121, 3, 88, 44, 0, 121, 122, 5, 88, 0, 0, 122, 124, 1, 0, 0, 0, 123, 119, 1, 0, 0, 0, 123, 124, 1, 0, 0, 0, 124, 125, 1, 0, 0, 0, 125, 126, 5, 90, 0, 0, 126, 127, 3, 16, 8, 0, 127, 11, 1, 0, 0, 0, 128, 130, 3, 8, 4, 0, 129, 131, 3, 10, 5, 0, 130, 129, 1, 0, 0, 0, 131, 132, 1, 0, 0, 0, 132, 130, 1, 0, 0, 0, 132, 133, 1, 0, 0, 0, 133, 13, 1, 0, 0, 0, 134, 139, 3, 18, 9, 0, 135, 136, 5, 89, 0, 0, 136, 138, 3, 18, 9, 0, 137, 135, 1, 0, 0, 0, 138, 141, 1, 0, 0, 0, 139, 137, 1, 0, 0, 0, 139, 140, 1, 0, 0, 0, 140, 15, 1, 0, 0, 0, 141, 139, 1, 0, 0, 0, 142, 145, 3, 18, 9, 0, 143, 145, 3, 80, 40, 0, 144, 142, 1, 0, 0, 0, 144, 143, 1, 0, 0, 0, 145, 17, 1, 0, 0, 0, 146, 163, 3, 22, 11, 0, 147, 163, 3, 24, 12, 0, 148, 163, 3, 26, 13, 0, 149, 163, 3, 28, 14, 0, 150, 163, 3, 30, 15, 0, 151, 163, 3, 32, 16, 0, 152, 163, 3, 34, 17, 0, 153, 163, 3, 38, 19, 0, 154, 163, 3, 40, 20, 0, 155, 163, 3, 36, 18, 0, 156, 163, 3, 42, 21, 0, 157, 163, 3, 44, 22, 0, 158, 163, 3, 46, 23, 0, 159, 163, 3, 48, 24, 0, 160, 163, 3, 50, 25, 0, 161, 163, 3, 52, 26, 0, 162, 146, 1, 0, 0, 0, 162, 147, 1, 0, 0, 0, 162, 148, 1, 0, 0, 0, 162, 149, 1, 0, 0, 0, 162, 150, 1, 0, 0, 0, 162, 151, 1, 0, 0, 0, 162, 152, 1, 0, 0, 0, 162, 153, 1, 0, 0, 0, 162, 154, 1, 0, 0, 0, 162, 155, 1, 0, 0, 0, 162, 156, 1, 0, 0, 0, 162, 157, 1, 0, 0, 0, 162, 158, 1, 0, 0, 0, 162, 159, 1, 0, 0, 0, 162, 160, 1, 0, 0, 0, 162, 161, 1, 0, 0, 0, 163, 19, 1, 0, 0, 0, 164, 165, 7, 0, 0, 0, 165, 21, 1, 0, 0, 0, 166, 167, 5, 32, 0, 0, 167, 168, 5, 81, 0, 0, 168, 169, 3, 60, 30, 0, 169, 23, 1, 0, 0, 0, 170, 171, 5, 14, 0, 0, 171, 172, 5, 81, 0, 0, 172, 173, 5, 41, 0, 0, 173, 25, 1, 0, 0, 0, 174, 175, 5, 14, 0, 0, 175, 176, 5, 81, 0, 0, 176, 177, 5, 42, 0, 0, 177, 27, 1, 0, 0, 0, 178, 179, 5, 14, 0, 0, 179, 180, 5, 81, 0, 0, 180, 181, 5, 43, 0, 0, 181, 29, 1, 0, 0, 0, 182, 183, 5, 14, 0, 0, 183, 184, 5, 81, 0, 0, 184, 185, 5, 44, 0, 0, 185, 31, 1, 0, 0, 0, 186, 187, 3, 20, 10, 0, 187, 188, 5, 81, 0, 0, 188, 189, 5, 45, 0, 0, 189, 33, 1, 0, 0, 0, 190, 191, 3, 20, 10, 0, 191, 192, 5, 81, 0, 0, 192, 193, 5, 46, 0, 0, 193, 35, 1, 0, 0, 0, 194, 195, 3, 20, 10, 0, 195, 196, 5, 81, 0, 0, 196, 197, 3, 70, 35, 0, 197, 37, 1, 0, 0, 0, 198, 199, 5, 17, 0, 0, 199, 200, 5, 81, 0, 0, 200, 201, 5, 68, 0, 0, 201, 39, 1, 0, 0, 0, 202, 203, 5, 33, 0, 0, 203, 204, 5, 81, 0, 0, 204, 205, 5, 69, 0, 0, 205, 41, 1, 0, 0, 0, 206, 207, 5, 21, 0, 0, 207, 208, 5, 81, 0, 0, 208, 209, 5, 51, 0, 0, 209, 43, 1, 0, 0, 0, 210, 211, 5, 20, 0, 0, 211, 212, 5, 81, 0, 0, 212, 213, 5, 52, 0, 0, 213, 45, 1, 0, 0, 0, 214, 215, 5, 19, 0, 0, 215, 216, 5, 81, 0, 0, 216, 217, 5, 71, 0, 0, 217, 47, 1, 0, 0, 0, 218, 219, 5, 18, 0, 0, 219, 220, 5, 81, 0, 0, 220, 221, 5, 72, 0, 0, 221, 49, 1, 0, 0, 0, 222, 223, 5, 30, 0, 0, 223, 224, 5, 81, 0, 0, 224, 225, 5, 73, 0, 0, 225, 51, 1, 0, 0, 0, 226, 227, 5, 31, 0, 0, 227, 228, 5, 81, 0, 0, 228, 229, 5, 74, 0, 0, 229, 53, 1, 0, 0, 0, 230, 231, 5, 22, 0, 0, 231, 232, 5, 14, 0, 0, 232, 233, 5, 24, 0, 0, 233, 236, 1, 0, 0, 0, 234, 235, 5, 14, 0, 0, 235, 237, 5, 25, 0, 0, 236, 234, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 242, 1, 0, 0, 0, 238, 239, 5, 22, 0, 0, 239, 240, 5, 14, 0, 0, 240, 242, 5, 25, 0, 0, 241, 230, 1, 0, 0, 0, 241, 238, 1, 0, 0, 0, 242, 55, 1, 0, 0, 0, 243, 244, 5, 22, 0, 0, 244, 245, 5, 14, 0, 0, 245, 246, 5, 26, 0, 0, 246, 249, 1, 0, 0, 0, 247, 248, 5, 23, 0, 0, 248, 250, 3, 58, 29, 0, 249, 247, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 255, 1, 0, 0, 0, 251, 252, 5, 22, 0, 0, 252, 253, 5, 23, 0, 0, 253, 255, 3, 58, 29, 0, 254, 243, 1, 0, 0, 0, 254, 251, 1, 0, 0, 0, 255, 57, 1, 0, 0, 0, 256, 257, 5, 14, 0, 0, 257, 260, 5, 27, 0, 0, 258, 259, 5, 14, 0, 0, 259, 261, 5, 25, 0, 0, 260, 258, 1, 0, 0, 0, 260, 261, 1, 0, 0, 0, 261, 264, 1, 0, 0, 0, 262, 263, 5, 14, 0, 0, 263, 265, 5, 28, 0, 0, 264, 262, 1, 0, 0, 0, 264, 265, 1, 0, 0, 0, 265, 268, 1, 0, 0, 0, 266, 267, 5, 14, 0, 0, 267, 269, 5, 29, 0, 0, 268, 266, 1, 0, 0, 0, 268, 269, 1, 0, 0, 0, 269, 289, 1, 0, 0, 0, 270, 271, 5, 14, 0, 0, 271, 274, 5, 25, 0, 0, 272, 273, 5, 14, 0, 0, 273, 275, 5, 28, 0, 0, 274, 272, 1, 0, 0, 0, 274, 275, 1, 0, 0, 0, 275, 278, 1, 0, 0, 0, 276, 277, 5, 14, 0, 0, 277, 279, 5, 29, 0, 0, 278, 276, 1, 0, 0, 0, 278, 279, 1, 0, 0, 0, 279, 289, 1, 0, 0, 0, 280, 281, 5, 14, 0, 0, 281, 284, 5, 28, 0, 0, 282, 283, 5, 14, 0, 0, 283, 285, 5, 29, 0, 0, 284, 282, 1, 0, 0, 0, 284, 285, 1, 0, 0, 0, 285, 289, 1, 0, 0, 0, 286, 287, 5, 14, 0, 0, 287, 289, 5, 29, 0, 0, 288, 256, 1, 0, 0, 0, 288, 270, 1, 0, 0, 0, 288, 280, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 289, 59, 1, 0, 0, 0, 290, 293, 3, 62, 31, 0, 291, 293, 3, 76, 38, 0, 292, 290, 1, 0, 0, 0, 292, 291, 1, 0, 0, 0, 293, 61, 1, 0, 0, 0, 294, 313, 5, 68, 0, 0, 295, 313, 5, 41, 0, 0, 296, 313, 5, 42, 0, 0, 297, 313, 5, 43, 0, 0, 298, 313, 5, 44, 0, 0, 299, 313, 5, 45, 0, 0, 300, 313, 5, 46, 0, 0, 301, 313, 5, 69, 0, 0, 302, 313, 5, 48, 0, 0, 303, 313, 5, 71, 0, 0, 304, 313, 5, 72, 0, 0, 305, 313, 5, 51, 0, 0, 306, 313, 5, 52, 0, 0, 307, 313, 5, 74, 0, 0, 308, 313, 5, 73, 0, 0, 309, 313, 5, 55, 0, 0, 310, 311, 5, 67, 0, 0, 311, 313, 5, 82, 0, 0, 312, 294, 1, 0, 0, 0, 312, 295, 1, 0, 0, 0, 312, 296, 1, 0, 0, 0, 312, 297, 1, 0, 0, 0, 312, 298, 1, 0, 0, 0, 312, 299, 1, 0, 0, 0, 312, 300, 1, 0, 0, 0, 312, 301, 1, 0, 0, 0, 312, 302, 1, 0, 0, 0, 312, 303, 1, 0, 0, 0, 312, 304, 1, 0, 0, 0, 312, 305, 1, 0, 0, 0, 312, 306, 1, 0, 0, 0, 312, 307, 1, 0, 0, 0, 312, 308, 1, 0, 0, 0, 312, 309, 1, 0, 0, 0, 312, 310, 1, 0, 0, 0, 313, 63, 1, 0, 0, 0, 314, 316, 5, 78, 0, 0, 315, 317, 5, 92, 0, 0, 316, 315, 1, 0, 0, 0, 316, 317, 1, 0, 0, 0, 317, 318, 1, 0, 0, 0, 318, 319, 5, 83, 0, 0, 319, 320, 3, 78, 39, 0, 320, 321, 5, 84, 0, 0, 321, 65, 1, 0, 0, 0, 322, 324, 5, 79, 0, 0, 323, 325, 5, 92, 0, 0, 324, 323, 1, 0, 0, 0, 324, 325, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 327, 5, 83, 0, 0, 327, 328, 3, 78, 39, 0, 328, 329, 5, 84, 0, 0, 329, 67, 1, 0, 0, 0, 330, 332, 5, 80, 0, 0, 331, 333, 5, 92, 0, 0, 332, 331, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 334, 1, 0, 0, 0, 334, 335, 5, 83, 0, 0, 335, 336, 3, 78, 39, 0, 336, 337, 5, 84, 0, 0, 337, 69, 1, 0, 0, 0, 338, 340, 5, 75, 0, 0, 339, 341, 5, 92, 0, 0, 340, 339, 1, 0, 0, 0, 340, 341, 1, 0, 0, 0, 341, 348, 1, 0, 0, 0, 342, 343, 5, 83, 0, 0, 343, 344, 3, 78, 39, 0, 344, 345, 5, 89, 0, 0, 345, 346, 3, 78, 39, 0, 346, 347, 5, 84, 0, 0, 347, 349, 1, 0, 0, 0, 348, 342, 1, 0, 0, 0, 348, 349, 1, 0, 0, 0, 349, 71, 1, 0, 0, 0, 350, 352, 5, 76, 0, 0, 351, 353, 5, 92, 0, 0, 352, 351, 1, 0, 0, 0, 352, 353, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 355, 5, 83, 0, 0, 355, 356, 3, 78, 39, 0, 356, 357, 5, 84, 0, 0, 357, 73, 1, 0, 0, 0, 358, 360, 5, 77, 0, 0, 359, 361, 5, 92, 0, 0, 360, 359, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 363, 5, 83, 0, 0, 363, 364, 3, 78, 39, 0, 364, 365, 5, 84, 0, 0, 365, 75, 1, 0, 0, 0, 366, 373, 3, 64, 32, 0, 367, 373, 3, 66, 33, 0, 368, 373, 3, 68, 34, 0, 369, 373, 3, 70, 35, 0, 370, 373, 3, 72, 36, 0, 371, 373, 3, 74, 37, 0, 372, 366, 1, 0, 0, 0, 372, 367, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 372, 369, 1, 0, 0, 0, 372, 370, 1, 0, 0, 0, 372, 371, 1, 0, 0, 0, 373, 77, 1, 0, 0, 0, 374, 375, 5, 14, 0, 0, 375, 79, 1, 0, 0, 0, 376, 377, 7, 1, 0, 0, 377, 81, 1, 0, 0, 0, 378, 379, 3, 84, 42, 0, 379, 380, 5, 91, 0, 0, 380, 381, 3, 86, 43, 0, 381, 83, 1, 0, 0, 0, 382, 383, 7, 2, 0, 0, 383, 85, 1, 0, 0, 0, 384, 385, 7, 3, 0, 0, 385, 87, 1, 0, 0, 0, 386, 391, 3, 82, 41, 0, 387, 388, 5, 89, 0, 0, 388, 390, 3, 82, 41, 0, 389, 387, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 89, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 29, 94, 110, 123, 132, 139, 144, 162, 236, 241, 249, 254, 260, 264, 268, 274, 278, 284, 288, 292, 312, 316, 324, 332, 340, 348, 352, 360, 372, 391] \ No newline at end of file +[4, 1, 95, 395, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 1, 0, 1, 0, 4, 0, 93, 8, 0, 11, 0, 12, 0, 94, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 109, 8, 3, 10, 3, 12, 3, 112, 9, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 124, 8, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 4, 6, 131, 8, 6, 11, 6, 12, 6, 132, 1, 7, 1, 7, 1, 7, 5, 7, 138, 8, 7, 10, 7, 12, 7, 141, 9, 7, 1, 8, 1, 8, 3, 8, 145, 8, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 163, 8, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 237, 8, 27, 1, 27, 1, 27, 1, 27, 3, 27, 242, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 250, 8, 28, 1, 28, 1, 28, 1, 28, 3, 28, 255, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 261, 8, 29, 1, 29, 1, 29, 3, 29, 265, 8, 29, 1, 29, 1, 29, 3, 29, 269, 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 275, 8, 29, 1, 29, 1, 29, 3, 29, 279, 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 285, 8, 29, 1, 29, 1, 29, 3, 29, 289, 8, 29, 1, 30, 1, 30, 3, 30, 293, 8, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 313, 8, 31, 1, 32, 1, 32, 3, 32, 317, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 3, 33, 325, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 3, 34, 333, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 3, 35, 341, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 349, 8, 35, 1, 36, 1, 36, 3, 36, 353, 8, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 3, 37, 361, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 373, 8, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 5, 44, 390, 8, 44, 10, 44, 12, 44, 393, 9, 44, 1, 44, 0, 0, 45, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 0, 4, 1, 0, 14, 16, 1, 0, 5, 6, 2, 0, 7, 8, 83, 83, 1, 0, 9, 13, 413, 0, 90, 1, 0, 0, 0, 2, 98, 1, 0, 0, 0, 4, 101, 1, 0, 0, 0, 6, 104, 1, 0, 0, 0, 8, 113, 1, 0, 0, 0, 10, 115, 1, 0, 0, 0, 12, 128, 1, 0, 0, 0, 14, 134, 1, 0, 0, 0, 16, 144, 1, 0, 0, 0, 18, 162, 1, 0, 0, 0, 20, 164, 1, 0, 0, 0, 22, 166, 1, 0, 0, 0, 24, 170, 1, 0, 0, 0, 26, 174, 1, 0, 0, 0, 28, 178, 1, 0, 0, 0, 30, 182, 1, 0, 0, 0, 32, 186, 1, 0, 0, 0, 34, 190, 1, 0, 0, 0, 36, 194, 1, 0, 0, 0, 38, 198, 1, 0, 0, 0, 40, 202, 1, 0, 0, 0, 42, 206, 1, 0, 0, 0, 44, 210, 1, 0, 0, 0, 46, 214, 1, 0, 0, 0, 48, 218, 1, 0, 0, 0, 50, 222, 1, 0, 0, 0, 52, 226, 1, 0, 0, 0, 54, 241, 1, 0, 0, 0, 56, 254, 1, 0, 0, 0, 58, 288, 1, 0, 0, 0, 60, 292, 1, 0, 0, 0, 62, 312, 1, 0, 0, 0, 64, 314, 1, 0, 0, 0, 66, 322, 1, 0, 0, 0, 68, 330, 1, 0, 0, 0, 70, 338, 1, 0, 0, 0, 72, 350, 1, 0, 0, 0, 74, 358, 1, 0, 0, 0, 76, 372, 1, 0, 0, 0, 78, 374, 1, 0, 0, 0, 80, 376, 1, 0, 0, 0, 82, 378, 1, 0, 0, 0, 84, 382, 1, 0, 0, 0, 86, 384, 1, 0, 0, 0, 88, 386, 1, 0, 0, 0, 90, 92, 3, 2, 1, 0, 91, 93, 3, 12, 6, 0, 92, 91, 1, 0, 0, 0, 93, 94, 1, 0, 0, 0, 94, 92, 1, 0, 0, 0, 94, 95, 1, 0, 0, 0, 95, 96, 1, 0, 0, 0, 96, 97, 5, 0, 0, 1, 97, 1, 1, 0, 0, 0, 98, 99, 3, 4, 2, 0, 99, 100, 3, 6, 3, 0, 100, 3, 1, 0, 0, 0, 101, 102, 5, 1, 0, 0, 102, 103, 5, 2, 0, 0, 103, 5, 1, 0, 0, 0, 104, 105, 5, 3, 0, 0, 105, 110, 5, 33, 0, 0, 106, 107, 5, 90, 0, 0, 107, 109, 5, 33, 0, 0, 108, 106, 1, 0, 0, 0, 109, 112, 1, 0, 0, 0, 110, 108, 1, 0, 0, 0, 110, 111, 1, 0, 0, 0, 111, 7, 1, 0, 0, 0, 112, 110, 1, 0, 0, 0, 113, 114, 5, 4, 0, 0, 114, 9, 1, 0, 0, 0, 115, 116, 5, 83, 0, 0, 116, 117, 5, 86, 0, 0, 117, 118, 3, 14, 7, 0, 118, 123, 5, 87, 0, 0, 119, 120, 5, 88, 0, 0, 120, 121, 3, 88, 44, 0, 121, 122, 5, 89, 0, 0, 122, 124, 1, 0, 0, 0, 123, 119, 1, 0, 0, 0, 123, 124, 1, 0, 0, 0, 124, 125, 1, 0, 0, 0, 125, 126, 5, 91, 0, 0, 126, 127, 3, 16, 8, 0, 127, 11, 1, 0, 0, 0, 128, 130, 3, 8, 4, 0, 129, 131, 3, 10, 5, 0, 130, 129, 1, 0, 0, 0, 131, 132, 1, 0, 0, 0, 132, 130, 1, 0, 0, 0, 132, 133, 1, 0, 0, 0, 133, 13, 1, 0, 0, 0, 134, 139, 3, 18, 9, 0, 135, 136, 5, 90, 0, 0, 136, 138, 3, 18, 9, 0, 137, 135, 1, 0, 0, 0, 138, 141, 1, 0, 0, 0, 139, 137, 1, 0, 0, 0, 139, 140, 1, 0, 0, 0, 140, 15, 1, 0, 0, 0, 141, 139, 1, 0, 0, 0, 142, 145, 3, 18, 9, 0, 143, 145, 3, 80, 40, 0, 144, 142, 1, 0, 0, 0, 144, 143, 1, 0, 0, 0, 145, 17, 1, 0, 0, 0, 146, 163, 3, 22, 11, 0, 147, 163, 3, 24, 12, 0, 148, 163, 3, 26, 13, 0, 149, 163, 3, 28, 14, 0, 150, 163, 3, 30, 15, 0, 151, 163, 3, 32, 16, 0, 152, 163, 3, 34, 17, 0, 153, 163, 3, 38, 19, 0, 154, 163, 3, 40, 20, 0, 155, 163, 3, 36, 18, 0, 156, 163, 3, 42, 21, 0, 157, 163, 3, 44, 22, 0, 158, 163, 3, 46, 23, 0, 159, 163, 3, 48, 24, 0, 160, 163, 3, 50, 25, 0, 161, 163, 3, 52, 26, 0, 162, 146, 1, 0, 0, 0, 162, 147, 1, 0, 0, 0, 162, 148, 1, 0, 0, 0, 162, 149, 1, 0, 0, 0, 162, 150, 1, 0, 0, 0, 162, 151, 1, 0, 0, 0, 162, 152, 1, 0, 0, 0, 162, 153, 1, 0, 0, 0, 162, 154, 1, 0, 0, 0, 162, 155, 1, 0, 0, 0, 162, 156, 1, 0, 0, 0, 162, 157, 1, 0, 0, 0, 162, 158, 1, 0, 0, 0, 162, 159, 1, 0, 0, 0, 162, 160, 1, 0, 0, 0, 162, 161, 1, 0, 0, 0, 163, 19, 1, 0, 0, 0, 164, 165, 7, 0, 0, 0, 165, 21, 1, 0, 0, 0, 166, 167, 5, 32, 0, 0, 167, 168, 5, 82, 0, 0, 168, 169, 3, 60, 30, 0, 169, 23, 1, 0, 0, 0, 170, 171, 5, 14, 0, 0, 171, 172, 5, 82, 0, 0, 172, 173, 5, 41, 0, 0, 173, 25, 1, 0, 0, 0, 174, 175, 5, 14, 0, 0, 175, 176, 5, 82, 0, 0, 176, 177, 5, 42, 0, 0, 177, 27, 1, 0, 0, 0, 178, 179, 5, 14, 0, 0, 179, 180, 5, 82, 0, 0, 180, 181, 5, 43, 0, 0, 181, 29, 1, 0, 0, 0, 182, 183, 5, 14, 0, 0, 183, 184, 5, 82, 0, 0, 184, 185, 5, 44, 0, 0, 185, 31, 1, 0, 0, 0, 186, 187, 3, 20, 10, 0, 187, 188, 5, 82, 0, 0, 188, 189, 5, 45, 0, 0, 189, 33, 1, 0, 0, 0, 190, 191, 3, 20, 10, 0, 191, 192, 5, 82, 0, 0, 192, 193, 5, 46, 0, 0, 193, 35, 1, 0, 0, 0, 194, 195, 3, 20, 10, 0, 195, 196, 5, 82, 0, 0, 196, 197, 3, 70, 35, 0, 197, 37, 1, 0, 0, 0, 198, 199, 5, 17, 0, 0, 199, 200, 5, 82, 0, 0, 200, 201, 5, 69, 0, 0, 201, 39, 1, 0, 0, 0, 202, 203, 5, 33, 0, 0, 203, 204, 5, 82, 0, 0, 204, 205, 5, 70, 0, 0, 205, 41, 1, 0, 0, 0, 206, 207, 5, 21, 0, 0, 207, 208, 5, 82, 0, 0, 208, 209, 5, 51, 0, 0, 209, 43, 1, 0, 0, 0, 210, 211, 5, 20, 0, 0, 211, 212, 5, 82, 0, 0, 212, 213, 5, 52, 0, 0, 213, 45, 1, 0, 0, 0, 214, 215, 5, 19, 0, 0, 215, 216, 5, 82, 0, 0, 216, 217, 5, 72, 0, 0, 217, 47, 1, 0, 0, 0, 218, 219, 5, 18, 0, 0, 219, 220, 5, 82, 0, 0, 220, 221, 5, 73, 0, 0, 221, 49, 1, 0, 0, 0, 222, 223, 5, 30, 0, 0, 223, 224, 5, 82, 0, 0, 224, 225, 5, 74, 0, 0, 225, 51, 1, 0, 0, 0, 226, 227, 5, 31, 0, 0, 227, 228, 5, 82, 0, 0, 228, 229, 5, 75, 0, 0, 229, 53, 1, 0, 0, 0, 230, 231, 5, 22, 0, 0, 231, 232, 5, 14, 0, 0, 232, 233, 5, 24, 0, 0, 233, 236, 1, 0, 0, 0, 234, 235, 5, 14, 0, 0, 235, 237, 5, 25, 0, 0, 236, 234, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 242, 1, 0, 0, 0, 238, 239, 5, 22, 0, 0, 239, 240, 5, 14, 0, 0, 240, 242, 5, 25, 0, 0, 241, 230, 1, 0, 0, 0, 241, 238, 1, 0, 0, 0, 242, 55, 1, 0, 0, 0, 243, 244, 5, 22, 0, 0, 244, 245, 5, 14, 0, 0, 245, 246, 5, 26, 0, 0, 246, 249, 1, 0, 0, 0, 247, 248, 5, 23, 0, 0, 248, 250, 3, 58, 29, 0, 249, 247, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 255, 1, 0, 0, 0, 251, 252, 5, 22, 0, 0, 252, 253, 5, 23, 0, 0, 253, 255, 3, 58, 29, 0, 254, 243, 1, 0, 0, 0, 254, 251, 1, 0, 0, 0, 255, 57, 1, 0, 0, 0, 256, 257, 5, 14, 0, 0, 257, 260, 5, 27, 0, 0, 258, 259, 5, 14, 0, 0, 259, 261, 5, 25, 0, 0, 260, 258, 1, 0, 0, 0, 260, 261, 1, 0, 0, 0, 261, 264, 1, 0, 0, 0, 262, 263, 5, 14, 0, 0, 263, 265, 5, 28, 0, 0, 264, 262, 1, 0, 0, 0, 264, 265, 1, 0, 0, 0, 265, 268, 1, 0, 0, 0, 266, 267, 5, 14, 0, 0, 267, 269, 5, 29, 0, 0, 268, 266, 1, 0, 0, 0, 268, 269, 1, 0, 0, 0, 269, 289, 1, 0, 0, 0, 270, 271, 5, 14, 0, 0, 271, 274, 5, 25, 0, 0, 272, 273, 5, 14, 0, 0, 273, 275, 5, 28, 0, 0, 274, 272, 1, 0, 0, 0, 274, 275, 1, 0, 0, 0, 275, 278, 1, 0, 0, 0, 276, 277, 5, 14, 0, 0, 277, 279, 5, 29, 0, 0, 278, 276, 1, 0, 0, 0, 278, 279, 1, 0, 0, 0, 279, 289, 1, 0, 0, 0, 280, 281, 5, 14, 0, 0, 281, 284, 5, 28, 0, 0, 282, 283, 5, 14, 0, 0, 283, 285, 5, 29, 0, 0, 284, 282, 1, 0, 0, 0, 284, 285, 1, 0, 0, 0, 285, 289, 1, 0, 0, 0, 286, 287, 5, 14, 0, 0, 287, 289, 5, 29, 0, 0, 288, 256, 1, 0, 0, 0, 288, 270, 1, 0, 0, 0, 288, 280, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 289, 59, 1, 0, 0, 0, 290, 293, 3, 62, 31, 0, 291, 293, 3, 76, 38, 0, 292, 290, 1, 0, 0, 0, 292, 291, 1, 0, 0, 0, 293, 61, 1, 0, 0, 0, 294, 313, 5, 69, 0, 0, 295, 313, 5, 41, 0, 0, 296, 313, 5, 42, 0, 0, 297, 313, 5, 43, 0, 0, 298, 313, 5, 44, 0, 0, 299, 313, 5, 45, 0, 0, 300, 313, 5, 46, 0, 0, 301, 313, 5, 70, 0, 0, 302, 313, 5, 48, 0, 0, 303, 313, 5, 72, 0, 0, 304, 313, 5, 73, 0, 0, 305, 313, 5, 51, 0, 0, 306, 313, 5, 52, 0, 0, 307, 313, 5, 75, 0, 0, 308, 313, 5, 74, 0, 0, 309, 313, 5, 55, 0, 0, 310, 311, 5, 67, 0, 0, 311, 313, 5, 83, 0, 0, 312, 294, 1, 0, 0, 0, 312, 295, 1, 0, 0, 0, 312, 296, 1, 0, 0, 0, 312, 297, 1, 0, 0, 0, 312, 298, 1, 0, 0, 0, 312, 299, 1, 0, 0, 0, 312, 300, 1, 0, 0, 0, 312, 301, 1, 0, 0, 0, 312, 302, 1, 0, 0, 0, 312, 303, 1, 0, 0, 0, 312, 304, 1, 0, 0, 0, 312, 305, 1, 0, 0, 0, 312, 306, 1, 0, 0, 0, 312, 307, 1, 0, 0, 0, 312, 308, 1, 0, 0, 0, 312, 309, 1, 0, 0, 0, 312, 310, 1, 0, 0, 0, 313, 63, 1, 0, 0, 0, 314, 316, 5, 79, 0, 0, 315, 317, 5, 93, 0, 0, 316, 315, 1, 0, 0, 0, 316, 317, 1, 0, 0, 0, 317, 318, 1, 0, 0, 0, 318, 319, 5, 84, 0, 0, 319, 320, 3, 78, 39, 0, 320, 321, 5, 85, 0, 0, 321, 65, 1, 0, 0, 0, 322, 324, 5, 80, 0, 0, 323, 325, 5, 93, 0, 0, 324, 323, 1, 0, 0, 0, 324, 325, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 327, 5, 84, 0, 0, 327, 328, 3, 78, 39, 0, 328, 329, 5, 85, 0, 0, 329, 67, 1, 0, 0, 0, 330, 332, 5, 81, 0, 0, 331, 333, 5, 93, 0, 0, 332, 331, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 334, 1, 0, 0, 0, 334, 335, 5, 84, 0, 0, 335, 336, 3, 78, 39, 0, 336, 337, 5, 85, 0, 0, 337, 69, 1, 0, 0, 0, 338, 340, 5, 76, 0, 0, 339, 341, 5, 93, 0, 0, 340, 339, 1, 0, 0, 0, 340, 341, 1, 0, 0, 0, 341, 348, 1, 0, 0, 0, 342, 343, 5, 84, 0, 0, 343, 344, 3, 78, 39, 0, 344, 345, 5, 90, 0, 0, 345, 346, 3, 78, 39, 0, 346, 347, 5, 85, 0, 0, 347, 349, 1, 0, 0, 0, 348, 342, 1, 0, 0, 0, 348, 349, 1, 0, 0, 0, 349, 71, 1, 0, 0, 0, 350, 352, 5, 77, 0, 0, 351, 353, 5, 93, 0, 0, 352, 351, 1, 0, 0, 0, 352, 353, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 355, 5, 84, 0, 0, 355, 356, 3, 78, 39, 0, 356, 357, 5, 85, 0, 0, 357, 73, 1, 0, 0, 0, 358, 360, 5, 78, 0, 0, 359, 361, 5, 93, 0, 0, 360, 359, 1, 0, 0, 0, 360, 361, 1, 0, 0, 0, 361, 362, 1, 0, 0, 0, 362, 363, 5, 84, 0, 0, 363, 364, 3, 78, 39, 0, 364, 365, 5, 85, 0, 0, 365, 75, 1, 0, 0, 0, 366, 373, 3, 64, 32, 0, 367, 373, 3, 66, 33, 0, 368, 373, 3, 68, 34, 0, 369, 373, 3, 70, 35, 0, 370, 373, 3, 72, 36, 0, 371, 373, 3, 74, 37, 0, 372, 366, 1, 0, 0, 0, 372, 367, 1, 0, 0, 0, 372, 368, 1, 0, 0, 0, 372, 369, 1, 0, 0, 0, 372, 370, 1, 0, 0, 0, 372, 371, 1, 0, 0, 0, 373, 77, 1, 0, 0, 0, 374, 375, 5, 14, 0, 0, 375, 79, 1, 0, 0, 0, 376, 377, 7, 1, 0, 0, 377, 81, 1, 0, 0, 0, 378, 379, 3, 84, 42, 0, 379, 380, 5, 92, 0, 0, 380, 381, 3, 86, 43, 0, 381, 83, 1, 0, 0, 0, 382, 383, 7, 2, 0, 0, 383, 85, 1, 0, 0, 0, 384, 385, 7, 3, 0, 0, 385, 87, 1, 0, 0, 0, 386, 391, 3, 82, 41, 0, 387, 388, 5, 90, 0, 0, 388, 390, 3, 82, 41, 0, 389, 387, 1, 0, 0, 0, 390, 393, 1, 0, 0, 0, 391, 389, 1, 0, 0, 0, 391, 392, 1, 0, 0, 0, 392, 89, 1, 0, 0, 0, 393, 391, 1, 0, 0, 0, 29, 94, 110, 123, 132, 139, 144, 162, 236, 241, 249, 254, 260, 264, 268, 274, 278, 284, 288, 292, 312, 316, 324, 332, 340, 348, 352, 360, 372, 391] \ No newline at end of file diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py new file mode 100644 index 000000000..3ae45d866 --- /dev/null +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -0,0 +1,4127 @@ +# Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +import sys +if sys.version_info[1] > 5: + from typing import TextIO +else: + from typing.io import TextIO + +def serializedATN(): + return [ + 4,1,95,395,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, + 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13, + 2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20, + 7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26, + 2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33, + 7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39, + 2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,1,0,1,0,4,0,93, + 8,0,11,0,12,0,94,1,0,1,0,1,1,1,1,1,1,1,2,1,2,1,2,1,3,1,3,1,3,1,3, + 5,3,109,8,3,10,3,12,3,112,9,3,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1, + 5,1,5,3,5,124,8,5,1,5,1,5,1,5,1,6,1,6,4,6,131,8,6,11,6,12,6,132, + 1,7,1,7,1,7,5,7,138,8,7,10,7,12,7,141,9,7,1,8,1,8,3,8,145,8,8,1, + 9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3, + 9,163,8,9,1,10,1,10,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13, + 1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16, + 1,16,1,16,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,19,1,19,1,19, + 1,19,1,20,1,20,1,20,1,20,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22, + 1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,26, + 1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,3,27,237,8,27,1,27, + 1,27,1,27,3,27,242,8,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,250,8, + 28,1,28,1,28,1,28,3,28,255,8,28,1,29,1,29,1,29,1,29,3,29,261,8,29, + 1,29,1,29,3,29,265,8,29,1,29,1,29,3,29,269,8,29,1,29,1,29,1,29,1, + 29,3,29,275,8,29,1,29,1,29,3,29,279,8,29,1,29,1,29,1,29,1,29,3,29, + 285,8,29,1,29,1,29,3,29,289,8,29,1,30,1,30,3,30,293,8,30,1,31,1, + 31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1, + 31,1,31,1,31,1,31,3,31,313,8,31,1,32,1,32,3,32,317,8,32,1,32,1,32, + 1,32,1,32,1,33,1,33,3,33,325,8,33,1,33,1,33,1,33,1,33,1,34,1,34, + 3,34,333,8,34,1,34,1,34,1,34,1,34,1,35,1,35,3,35,341,8,35,1,35,1, + 35,1,35,1,35,1,35,1,35,3,35,349,8,35,1,36,1,36,3,36,353,8,36,1,36, + 1,36,1,36,1,36,1,37,1,37,3,37,361,8,37,1,37,1,37,1,37,1,37,1,38, + 1,38,1,38,1,38,1,38,1,38,3,38,373,8,38,1,39,1,39,1,40,1,40,1,41, + 1,41,1,41,1,41,1,42,1,42,1,43,1,43,1,44,1,44,1,44,5,44,390,8,44, + 10,44,12,44,393,9,44,1,44,0,0,45,0,2,4,6,8,10,12,14,16,18,20,22, + 24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66, + 68,70,72,74,76,78,80,82,84,86,88,0,4,1,0,14,16,1,0,5,6,2,0,7,8,83, + 83,1,0,9,13,413,0,90,1,0,0,0,2,98,1,0,0,0,4,101,1,0,0,0,6,104,1, + 0,0,0,8,113,1,0,0,0,10,115,1,0,0,0,12,128,1,0,0,0,14,134,1,0,0,0, + 16,144,1,0,0,0,18,162,1,0,0,0,20,164,1,0,0,0,22,166,1,0,0,0,24,170, + 1,0,0,0,26,174,1,0,0,0,28,178,1,0,0,0,30,182,1,0,0,0,32,186,1,0, + 0,0,34,190,1,0,0,0,36,194,1,0,0,0,38,198,1,0,0,0,40,202,1,0,0,0, + 42,206,1,0,0,0,44,210,1,0,0,0,46,214,1,0,0,0,48,218,1,0,0,0,50,222, + 1,0,0,0,52,226,1,0,0,0,54,241,1,0,0,0,56,254,1,0,0,0,58,288,1,0, + 0,0,60,292,1,0,0,0,62,312,1,0,0,0,64,314,1,0,0,0,66,322,1,0,0,0, + 68,330,1,0,0,0,70,338,1,0,0,0,72,350,1,0,0,0,74,358,1,0,0,0,76,372, + 1,0,0,0,78,374,1,0,0,0,80,376,1,0,0,0,82,378,1,0,0,0,84,382,1,0, + 0,0,86,384,1,0,0,0,88,386,1,0,0,0,90,92,3,2,1,0,91,93,3,12,6,0,92, + 91,1,0,0,0,93,94,1,0,0,0,94,92,1,0,0,0,94,95,1,0,0,0,95,96,1,0,0, + 0,96,97,5,0,0,1,97,1,1,0,0,0,98,99,3,4,2,0,99,100,3,6,3,0,100,3, + 1,0,0,0,101,102,5,1,0,0,102,103,5,2,0,0,103,5,1,0,0,0,104,105,5, + 3,0,0,105,110,5,33,0,0,106,107,5,90,0,0,107,109,5,33,0,0,108,106, + 1,0,0,0,109,112,1,0,0,0,110,108,1,0,0,0,110,111,1,0,0,0,111,7,1, + 0,0,0,112,110,1,0,0,0,113,114,5,4,0,0,114,9,1,0,0,0,115,116,5,83, + 0,0,116,117,5,86,0,0,117,118,3,14,7,0,118,123,5,87,0,0,119,120,5, + 88,0,0,120,121,3,88,44,0,121,122,5,89,0,0,122,124,1,0,0,0,123,119, + 1,0,0,0,123,124,1,0,0,0,124,125,1,0,0,0,125,126,5,91,0,0,126,127, + 3,16,8,0,127,11,1,0,0,0,128,130,3,8,4,0,129,131,3,10,5,0,130,129, + 1,0,0,0,131,132,1,0,0,0,132,130,1,0,0,0,132,133,1,0,0,0,133,13,1, + 0,0,0,134,139,3,18,9,0,135,136,5,90,0,0,136,138,3,18,9,0,137,135, + 1,0,0,0,138,141,1,0,0,0,139,137,1,0,0,0,139,140,1,0,0,0,140,15,1, + 0,0,0,141,139,1,0,0,0,142,145,3,18,9,0,143,145,3,80,40,0,144,142, + 1,0,0,0,144,143,1,0,0,0,145,17,1,0,0,0,146,163,3,22,11,0,147,163, + 3,24,12,0,148,163,3,26,13,0,149,163,3,28,14,0,150,163,3,30,15,0, + 151,163,3,32,16,0,152,163,3,34,17,0,153,163,3,38,19,0,154,163,3, + 40,20,0,155,163,3,36,18,0,156,163,3,42,21,0,157,163,3,44,22,0,158, + 163,3,46,23,0,159,163,3,48,24,0,160,163,3,50,25,0,161,163,3,52,26, + 0,162,146,1,0,0,0,162,147,1,0,0,0,162,148,1,0,0,0,162,149,1,0,0, + 0,162,150,1,0,0,0,162,151,1,0,0,0,162,152,1,0,0,0,162,153,1,0,0, + 0,162,154,1,0,0,0,162,155,1,0,0,0,162,156,1,0,0,0,162,157,1,0,0, + 0,162,158,1,0,0,0,162,159,1,0,0,0,162,160,1,0,0,0,162,161,1,0,0, + 0,163,19,1,0,0,0,164,165,7,0,0,0,165,21,1,0,0,0,166,167,5,32,0,0, + 167,168,5,82,0,0,168,169,3,60,30,0,169,23,1,0,0,0,170,171,5,14,0, + 0,171,172,5,82,0,0,172,173,5,41,0,0,173,25,1,0,0,0,174,175,5,14, + 0,0,175,176,5,82,0,0,176,177,5,42,0,0,177,27,1,0,0,0,178,179,5,14, + 0,0,179,180,5,82,0,0,180,181,5,43,0,0,181,29,1,0,0,0,182,183,5,14, + 0,0,183,184,5,82,0,0,184,185,5,44,0,0,185,31,1,0,0,0,186,187,3,20, + 10,0,187,188,5,82,0,0,188,189,5,45,0,0,189,33,1,0,0,0,190,191,3, + 20,10,0,191,192,5,82,0,0,192,193,5,46,0,0,193,35,1,0,0,0,194,195, + 3,20,10,0,195,196,5,82,0,0,196,197,3,70,35,0,197,37,1,0,0,0,198, + 199,5,17,0,0,199,200,5,82,0,0,200,201,5,69,0,0,201,39,1,0,0,0,202, + 203,5,33,0,0,203,204,5,82,0,0,204,205,5,70,0,0,205,41,1,0,0,0,206, + 207,5,21,0,0,207,208,5,82,0,0,208,209,5,51,0,0,209,43,1,0,0,0,210, + 211,5,20,0,0,211,212,5,82,0,0,212,213,5,52,0,0,213,45,1,0,0,0,214, + 215,5,19,0,0,215,216,5,82,0,0,216,217,5,72,0,0,217,47,1,0,0,0,218, + 219,5,18,0,0,219,220,5,82,0,0,220,221,5,73,0,0,221,49,1,0,0,0,222, + 223,5,30,0,0,223,224,5,82,0,0,224,225,5,74,0,0,225,51,1,0,0,0,226, + 227,5,31,0,0,227,228,5,82,0,0,228,229,5,75,0,0,229,53,1,0,0,0,230, + 231,5,22,0,0,231,232,5,14,0,0,232,233,5,24,0,0,233,236,1,0,0,0,234, + 235,5,14,0,0,235,237,5,25,0,0,236,234,1,0,0,0,236,237,1,0,0,0,237, + 242,1,0,0,0,238,239,5,22,0,0,239,240,5,14,0,0,240,242,5,25,0,0,241, + 230,1,0,0,0,241,238,1,0,0,0,242,55,1,0,0,0,243,244,5,22,0,0,244, + 245,5,14,0,0,245,246,5,26,0,0,246,249,1,0,0,0,247,248,5,23,0,0,248, + 250,3,58,29,0,249,247,1,0,0,0,249,250,1,0,0,0,250,255,1,0,0,0,251, + 252,5,22,0,0,252,253,5,23,0,0,253,255,3,58,29,0,254,243,1,0,0,0, + 254,251,1,0,0,0,255,57,1,0,0,0,256,257,5,14,0,0,257,260,5,27,0,0, + 258,259,5,14,0,0,259,261,5,25,0,0,260,258,1,0,0,0,260,261,1,0,0, + 0,261,264,1,0,0,0,262,263,5,14,0,0,263,265,5,28,0,0,264,262,1,0, + 0,0,264,265,1,0,0,0,265,268,1,0,0,0,266,267,5,14,0,0,267,269,5,29, + 0,0,268,266,1,0,0,0,268,269,1,0,0,0,269,289,1,0,0,0,270,271,5,14, + 0,0,271,274,5,25,0,0,272,273,5,14,0,0,273,275,5,28,0,0,274,272,1, + 0,0,0,274,275,1,0,0,0,275,278,1,0,0,0,276,277,5,14,0,0,277,279,5, + 29,0,0,278,276,1,0,0,0,278,279,1,0,0,0,279,289,1,0,0,0,280,281,5, + 14,0,0,281,284,5,28,0,0,282,283,5,14,0,0,283,285,5,29,0,0,284,282, + 1,0,0,0,284,285,1,0,0,0,285,289,1,0,0,0,286,287,5,14,0,0,287,289, + 5,29,0,0,288,256,1,0,0,0,288,270,1,0,0,0,288,280,1,0,0,0,288,286, + 1,0,0,0,289,59,1,0,0,0,290,293,3,62,31,0,291,293,3,76,38,0,292,290, + 1,0,0,0,292,291,1,0,0,0,293,61,1,0,0,0,294,313,5,69,0,0,295,313, + 5,41,0,0,296,313,5,42,0,0,297,313,5,43,0,0,298,313,5,44,0,0,299, + 313,5,45,0,0,300,313,5,46,0,0,301,313,5,70,0,0,302,313,5,48,0,0, + 303,313,5,72,0,0,304,313,5,73,0,0,305,313,5,51,0,0,306,313,5,52, + 0,0,307,313,5,75,0,0,308,313,5,74,0,0,309,313,5,55,0,0,310,311,5, + 67,0,0,311,313,5,83,0,0,312,294,1,0,0,0,312,295,1,0,0,0,312,296, + 1,0,0,0,312,297,1,0,0,0,312,298,1,0,0,0,312,299,1,0,0,0,312,300, + 1,0,0,0,312,301,1,0,0,0,312,302,1,0,0,0,312,303,1,0,0,0,312,304, + 1,0,0,0,312,305,1,0,0,0,312,306,1,0,0,0,312,307,1,0,0,0,312,308, + 1,0,0,0,312,309,1,0,0,0,312,310,1,0,0,0,313,63,1,0,0,0,314,316,5, + 79,0,0,315,317,5,93,0,0,316,315,1,0,0,0,316,317,1,0,0,0,317,318, + 1,0,0,0,318,319,5,84,0,0,319,320,3,78,39,0,320,321,5,85,0,0,321, + 65,1,0,0,0,322,324,5,80,0,0,323,325,5,93,0,0,324,323,1,0,0,0,324, + 325,1,0,0,0,325,326,1,0,0,0,326,327,5,84,0,0,327,328,3,78,39,0,328, + 329,5,85,0,0,329,67,1,0,0,0,330,332,5,81,0,0,331,333,5,93,0,0,332, + 331,1,0,0,0,332,333,1,0,0,0,333,334,1,0,0,0,334,335,5,84,0,0,335, + 336,3,78,39,0,336,337,5,85,0,0,337,69,1,0,0,0,338,340,5,76,0,0,339, + 341,5,93,0,0,340,339,1,0,0,0,340,341,1,0,0,0,341,348,1,0,0,0,342, + 343,5,84,0,0,343,344,3,78,39,0,344,345,5,90,0,0,345,346,3,78,39, + 0,346,347,5,85,0,0,347,349,1,0,0,0,348,342,1,0,0,0,348,349,1,0,0, + 0,349,71,1,0,0,0,350,352,5,77,0,0,351,353,5,93,0,0,352,351,1,0,0, + 0,352,353,1,0,0,0,353,354,1,0,0,0,354,355,5,84,0,0,355,356,3,78, + 39,0,356,357,5,85,0,0,357,73,1,0,0,0,358,360,5,78,0,0,359,361,5, + 93,0,0,360,359,1,0,0,0,360,361,1,0,0,0,361,362,1,0,0,0,362,363,5, + 84,0,0,363,364,3,78,39,0,364,365,5,85,0,0,365,75,1,0,0,0,366,373, + 3,64,32,0,367,373,3,66,33,0,368,373,3,68,34,0,369,373,3,70,35,0, + 370,373,3,72,36,0,371,373,3,74,37,0,372,366,1,0,0,0,372,367,1,0, + 0,0,372,368,1,0,0,0,372,369,1,0,0,0,372,370,1,0,0,0,372,371,1,0, + 0,0,373,77,1,0,0,0,374,375,5,14,0,0,375,79,1,0,0,0,376,377,7,1,0, + 0,377,81,1,0,0,0,378,379,3,84,42,0,379,380,5,92,0,0,380,381,3,86, + 43,0,381,83,1,0,0,0,382,383,7,2,0,0,383,85,1,0,0,0,384,385,7,3,0, + 0,385,87,1,0,0,0,386,391,3,82,41,0,387,388,5,90,0,0,388,390,3,82, + 41,0,389,387,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0, + 0,0,392,89,1,0,0,0,393,391,1,0,0,0,29,94,110,123,132,139,144,162, + 236,241,249,254,260,264,268,274,278,284,288,292,312,316,324,332, + 340,348,352,360,372,391 + ] + +class FuncTestCaseParser ( Parser ): + + grammarFileName = "FuncTestCaseParser.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "'### SUBSTRAIT_SCALAR_TEST:'", "", + "'### SUBSTRAIT_INCLUDE:'", "", "''", + "''", "'overlfow'", "'rounding'", "'ERROR'", + "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", + "", "", "", "", + "", "", "", "", + "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", + "", "", "'null'", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "", + "", "", "", "'::'", "", + "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", + "':'", "'?'", "'#'", "'.'" ] + + symbolicNames = [ "", "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", "DESCRIPTION_LINE", "ERROR_RESULT", + "UNDEFINED_RESULT", "OVERFLOW", "ROUNDING", "ERROR", + "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", + "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", + "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", + "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", "NULL_LITERAL", "STRING_LITERAL", + "LineComment", "BlockComment", "Whitespace", "If", + "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", + "FP32", "FP64", "String", "Binary", "Timestamp", "Timestamp_TZ", + "Date", "Time", "Interval_Year", "Interval_Day", "UUID", + "Decimal", "Precision_Timestamp", "Precision_Timestamp_TZ", + "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", + "List", "Map", "ANY", "UserDefined", "Geometry", "Bool", + "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", + "PTs", "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", + "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", + "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", + "EQ", "COLON", "QMARK", "HASH", "DOT" ] + + RULE_doc = 0 + RULE_header = 1 + RULE_version = 2 + RULE_include = 3 + RULE_testGroupDescription = 4 + RULE_testCase = 5 + RULE_testGroup = 6 + RULE_arguments = 7 + RULE_result = 8 + RULE_argument = 9 + RULE_numericLiteral = 10 + RULE_nullArg = 11 + RULE_i8Arg = 12 + RULE_i16Arg = 13 + RULE_i32Arg = 14 + RULE_i64Arg = 15 + RULE_fp32Arg = 16 + RULE_fp64Arg = 17 + RULE_decimalArg = 18 + RULE_booleanArg = 19 + RULE_stringArg = 20 + RULE_dateArg = 21 + RULE_timeArg = 22 + RULE_timestampArg = 23 + RULE_timestampTzArg = 24 + RULE_intervalYearArg = 25 + RULE_intervalDayArg = 26 + RULE_intervalYearLiteral = 27 + RULE_intervalDayLiteral = 28 + RULE_timeInterval = 29 + RULE_datatype = 30 + RULE_scalarType = 31 + RULE_fixedCharType = 32 + RULE_varCharType = 33 + RULE_fixedBinaryType = 34 + RULE_decimalType = 35 + RULE_precisionTimestampType = 36 + RULE_precisionTimestampTZType = 37 + RULE_parameterizedType = 38 + RULE_numericParameter = 39 + RULE_substraitError = 40 + RULE_func_option = 41 + RULE_option_name = 42 + RULE_option_value = 43 + RULE_func_options = 44 + + ruleNames = [ "doc", "header", "version", "include", "testGroupDescription", + "testCase", "testGroup", "arguments", "result", "argument", + "numericLiteral", "nullArg", "i8Arg", "i16Arg", "i32Arg", + "i64Arg", "fp32Arg", "fp64Arg", "decimalArg", "booleanArg", + "stringArg", "dateArg", "timeArg", "timestampArg", "timestampTzArg", + "intervalYearArg", "intervalDayArg", "intervalYearLiteral", + "intervalDayLiteral", "timeInterval", "datatype", "scalarType", + "fixedCharType", "varCharType", "fixedBinaryType", "decimalType", + "precisionTimestampType", "precisionTimestampTZType", + "parameterizedType", "numericParameter", "substraitError", + "func_option", "option_name", "option_value", "func_options" ] + + EOF = Token.EOF + SUBSTRAIT_SCALAR_TEST=1 + FORMAT_VERSION=2 + SUBSTRAIT_INCLUDE=3 + DESCRIPTION_LINE=4 + ERROR_RESULT=5 + UNDEFINED_RESULT=6 + OVERFLOW=7 + ROUNDING=8 + ERROR=9 + SATURATE=10 + SILENT=11 + TIE_TO_EVEN=12 + NAN=13 + INTEGER_LITERAL=14 + DECIMAL_LITERAL=15 + FLOAT_LITERAL=16 + BOOLEAN_LITERAL=17 + TIMESTAMP_TZ_LITERAL=18 + TIMESTAMP_LITERAL=19 + TIME_LITERAL=20 + DATE_LITERAL=21 + PERIOD_PREFIX=22 + TIME_PREFIX=23 + YEAR_SUFFIX=24 + M_SUFFIX=25 + DAY_SUFFIX=26 + HOUR_SUFFIX=27 + SECOND_SUFFIX=28 + FRACTIONAL_SECOND_SUFFIX=29 + INTERVAL_YEAR_LITERAL=30 + INTERVAL_DAY_LITERAL=31 + NULL_LITERAL=32 + STRING_LITERAL=33 + LineComment=34 + BlockComment=35 + Whitespace=36 + If=37 + Then=38 + Else=39 + Boolean=40 + I8=41 + I16=42 + I32=43 + I64=44 + FP32=45 + FP64=46 + String=47 + Binary=48 + Timestamp=49 + Timestamp_TZ=50 + Date=51 + Time=52 + Interval_Year=53 + Interval_Day=54 + UUID=55 + Decimal=56 + Precision_Timestamp=57 + Precision_Timestamp_TZ=58 + FixedChar=59 + VarChar=60 + FixedBinary=61 + Struct=62 + NStruct=63 + List=64 + Map=65 + ANY=66 + UserDefined=67 + Geometry=68 + Bool=69 + Str=70 + VBin=71 + Ts=72 + TsTZ=73 + IYear=74 + IDay=75 + Dec=76 + PTs=77 + PTsTZ=78 + FChar=79 + VChar=80 + FBin=81 + DOUBLE_COLON=82 + IDENTIFIER=83 + O_ANGLE_BRACKET=84 + C_ANGLE_BRACKET=85 + OPAREN=86 + CPAREN=87 + OBRACKET=88 + CBRACKET=89 + COMMA=90 + EQ=91 + COLON=92 + QMARK=93 + HASH=94 + DOT=95 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.13.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + + class DocContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def header(self): + return self.getTypedRuleContext(FuncTestCaseParser.HeaderContext,0) + + + def EOF(self): + return self.getToken(FuncTestCaseParser.EOF, 0) + + def testGroup(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.TestGroupContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.TestGroupContext,i) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_doc + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDoc" ): + listener.enterDoc(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDoc" ): + listener.exitDoc(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDoc" ): + return visitor.visitDoc(self) + else: + return visitor.visitChildren(self) + + + + + def doc(self): + + localctx = FuncTestCaseParser.DocContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_doc) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 90 + self.header() + self.state = 92 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 91 + self.testGroup() + self.state = 94 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==4): + break + + self.state = 96 + self.match(FuncTestCaseParser.EOF) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class HeaderContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def version(self): + return self.getTypedRuleContext(FuncTestCaseParser.VersionContext,0) + + + def include(self): + return self.getTypedRuleContext(FuncTestCaseParser.IncludeContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_header + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterHeader" ): + listener.enterHeader(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitHeader" ): + listener.exitHeader(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitHeader" ): + return visitor.visitHeader(self) + else: + return visitor.visitChildren(self) + + + + + def header(self): + + localctx = FuncTestCaseParser.HeaderContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_header) + try: + self.enterOuterAlt(localctx, 1) + self.state = 98 + self.version() + self.state = 99 + self.include() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VersionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUBSTRAIT_SCALAR_TEST(self): + return self.getToken(FuncTestCaseParser.SUBSTRAIT_SCALAR_TEST, 0) + + def FORMAT_VERSION(self): + return self.getToken(FuncTestCaseParser.FORMAT_VERSION, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_version + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVersion" ): + listener.enterVersion(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVersion" ): + listener.exitVersion(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVersion" ): + return visitor.visitVersion(self) + else: + return visitor.visitChildren(self) + + + + + def version(self): + + localctx = FuncTestCaseParser.VersionContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_version) + try: + self.enterOuterAlt(localctx, 1) + self.state = 101 + self.match(FuncTestCaseParser.SUBSTRAIT_SCALAR_TEST) + self.state = 102 + self.match(FuncTestCaseParser.FORMAT_VERSION) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IncludeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SUBSTRAIT_INCLUDE(self): + return self.getToken(FuncTestCaseParser.SUBSTRAIT_INCLUDE, 0) + + def STRING_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(FuncTestCaseParser.STRING_LITERAL) + else: + return self.getToken(FuncTestCaseParser.STRING_LITERAL, i) + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(FuncTestCaseParser.COMMA) + else: + return self.getToken(FuncTestCaseParser.COMMA, i) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_include + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInclude" ): + listener.enterInclude(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInclude" ): + listener.exitInclude(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitInclude" ): + return visitor.visitInclude(self) + else: + return visitor.visitChildren(self) + + + + + def include(self): + + localctx = FuncTestCaseParser.IncludeContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_include) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 104 + self.match(FuncTestCaseParser.SUBSTRAIT_INCLUDE) + self.state = 105 + self.match(FuncTestCaseParser.STRING_LITERAL) + self.state = 110 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==90: + self.state = 106 + self.match(FuncTestCaseParser.COMMA) + self.state = 107 + self.match(FuncTestCaseParser.STRING_LITERAL) + self.state = 112 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TestGroupDescriptionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DESCRIPTION_LINE(self): + return self.getToken(FuncTestCaseParser.DESCRIPTION_LINE, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_testGroupDescription + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTestGroupDescription" ): + listener.enterTestGroupDescription(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTestGroupDescription" ): + listener.exitTestGroupDescription(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTestGroupDescription" ): + return visitor.visitTestGroupDescription(self) + else: + return visitor.visitChildren(self) + + + + + def testGroupDescription(self): + + localctx = FuncTestCaseParser.TestGroupDescriptionContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_testGroupDescription) + try: + self.enterOuterAlt(localctx, 1) + self.state = 113 + self.match(FuncTestCaseParser.DESCRIPTION_LINE) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TestCaseContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.functionName = None # Token + + def OPAREN(self): + return self.getToken(FuncTestCaseParser.OPAREN, 0) + + def arguments(self): + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentsContext,0) + + + def CPAREN(self): + return self.getToken(FuncTestCaseParser.CPAREN, 0) + + def EQ(self): + return self.getToken(FuncTestCaseParser.EQ, 0) + + def result(self): + return self.getTypedRuleContext(FuncTestCaseParser.ResultContext,0) + + + def IDENTIFIER(self): + return self.getToken(FuncTestCaseParser.IDENTIFIER, 0) + + def OBRACKET(self): + return self.getToken(FuncTestCaseParser.OBRACKET, 0) + + def func_options(self): + return self.getTypedRuleContext(FuncTestCaseParser.Func_optionsContext,0) + + + def CBRACKET(self): + return self.getToken(FuncTestCaseParser.CBRACKET, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_testCase + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTestCase" ): + listener.enterTestCase(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTestCase" ): + listener.exitTestCase(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTestCase" ): + return visitor.visitTestCase(self) + else: + return visitor.visitChildren(self) + + + + + def testCase(self): + + localctx = FuncTestCaseParser.TestCaseContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_testCase) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 115 + localctx.functionName = self.match(FuncTestCaseParser.IDENTIFIER) + self.state = 116 + self.match(FuncTestCaseParser.OPAREN) + self.state = 117 + self.arguments() + self.state = 118 + self.match(FuncTestCaseParser.CPAREN) + self.state = 123 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==88: + self.state = 119 + self.match(FuncTestCaseParser.OBRACKET) + self.state = 120 + self.func_options() + self.state = 121 + self.match(FuncTestCaseParser.CBRACKET) + + + self.state = 125 + self.match(FuncTestCaseParser.EQ) + self.state = 126 + self.result() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TestGroupContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def testGroupDescription(self): + return self.getTypedRuleContext(FuncTestCaseParser.TestGroupDescriptionContext,0) + + + def testCase(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.TestCaseContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.TestCaseContext,i) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_testGroup + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTestGroup" ): + listener.enterTestGroup(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTestGroup" ): + listener.exitTestGroup(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTestGroup" ): + return visitor.visitTestGroup(self) + else: + return visitor.visitChildren(self) + + + + + def testGroup(self): + + localctx = FuncTestCaseParser.TestGroupContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_testGroup) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 128 + self.testGroupDescription() + self.state = 130 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 129 + self.testCase() + self.state = 132 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==83): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ArgumentsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def argument(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.ArgumentContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(FuncTestCaseParser.COMMA) + else: + return self.getToken(FuncTestCaseParser.COMMA, i) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_arguments + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArguments" ): + listener.enterArguments(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArguments" ): + listener.exitArguments(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArguments" ): + return visitor.visitArguments(self) + else: + return visitor.visitChildren(self) + + + + + def arguments(self): + + localctx = FuncTestCaseParser.ArgumentsContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_arguments) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 134 + self.argument() + self.state = 139 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==90: + self.state = 135 + self.match(FuncTestCaseParser.COMMA) + self.state = 136 + self.argument() + self.state = 141 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ResultContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def argument(self): + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext,0) + + + def substraitError(self): + return self.getTypedRuleContext(FuncTestCaseParser.SubstraitErrorContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_result + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterResult" ): + listener.enterResult(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitResult" ): + listener.exitResult(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitResult" ): + return visitor.visitResult(self) + else: + return visitor.visitChildren(self) + + + + + def result(self): + + localctx = FuncTestCaseParser.ResultContext(self, self._ctx, self.state) + self.enterRule(localctx, 16, self.RULE_result) + try: + self.state = 144 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [14, 15, 16, 17, 18, 19, 20, 21, 30, 31, 32, 33]: + self.enterOuterAlt(localctx, 1) + self.state = 142 + self.argument() + pass + elif token in [5, 6]: + self.enterOuterAlt(localctx, 2) + self.state = 143 + self.substraitError() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ArgumentContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def nullArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.NullArgContext,0) + + + def i8Arg(self): + return self.getTypedRuleContext(FuncTestCaseParser.I8ArgContext,0) + + + def i16Arg(self): + return self.getTypedRuleContext(FuncTestCaseParser.I16ArgContext,0) + + + def i32Arg(self): + return self.getTypedRuleContext(FuncTestCaseParser.I32ArgContext,0) + + + def i64Arg(self): + return self.getTypedRuleContext(FuncTestCaseParser.I64ArgContext,0) + + + def fp32Arg(self): + return self.getTypedRuleContext(FuncTestCaseParser.Fp32ArgContext,0) + + + def fp64Arg(self): + return self.getTypedRuleContext(FuncTestCaseParser.Fp64ArgContext,0) + + + def booleanArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.BooleanArgContext,0) + + + def stringArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.StringArgContext,0) + + + def decimalArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.DecimalArgContext,0) + + + def dateArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.DateArgContext,0) + + + def timeArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.TimeArgContext,0) + + + def timestampArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.TimestampArgContext,0) + + + def timestampTzArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.TimestampTzArgContext,0) + + + def intervalYearArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.IntervalYearArgContext,0) + + + def intervalDayArg(self): + return self.getTypedRuleContext(FuncTestCaseParser.IntervalDayArgContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_argument + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterArgument" ): + listener.enterArgument(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitArgument" ): + listener.exitArgument(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitArgument" ): + return visitor.visitArgument(self) + else: + return visitor.visitChildren(self) + + + + + def argument(self): + + localctx = FuncTestCaseParser.ArgumentContext(self, self._ctx, self.state) + self.enterRule(localctx, 18, self.RULE_argument) + try: + self.state = 162 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,6,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 146 + self.nullArg() + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 147 + self.i8Arg() + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 148 + self.i16Arg() + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 149 + self.i32Arg() + pass + + elif la_ == 5: + self.enterOuterAlt(localctx, 5) + self.state = 150 + self.i64Arg() + pass + + elif la_ == 6: + self.enterOuterAlt(localctx, 6) + self.state = 151 + self.fp32Arg() + pass + + elif la_ == 7: + self.enterOuterAlt(localctx, 7) + self.state = 152 + self.fp64Arg() + pass + + elif la_ == 8: + self.enterOuterAlt(localctx, 8) + self.state = 153 + self.booleanArg() + pass + + elif la_ == 9: + self.enterOuterAlt(localctx, 9) + self.state = 154 + self.stringArg() + pass + + elif la_ == 10: + self.enterOuterAlt(localctx, 10) + self.state = 155 + self.decimalArg() + pass + + elif la_ == 11: + self.enterOuterAlt(localctx, 11) + self.state = 156 + self.dateArg() + pass + + elif la_ == 12: + self.enterOuterAlt(localctx, 12) + self.state = 157 + self.timeArg() + pass + + elif la_ == 13: + self.enterOuterAlt(localctx, 13) + self.state = 158 + self.timestampArg() + pass + + elif la_ == 14: + self.enterOuterAlt(localctx, 14) + self.state = 159 + self.timestampTzArg() + pass + + elif la_ == 15: + self.enterOuterAlt(localctx, 15) + self.state = 160 + self.intervalYearArg() + pass + + elif la_ == 16: + self.enterOuterAlt(localctx, 16) + self.state = 161 + self.intervalDayArg() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NumericLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DECIMAL_LITERAL(self): + return self.getToken(FuncTestCaseParser.DECIMAL_LITERAL, 0) + + def INTEGER_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) + + def FLOAT_LITERAL(self): + return self.getToken(FuncTestCaseParser.FLOAT_LITERAL, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_numericLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNumericLiteral" ): + listener.enterNumericLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNumericLiteral" ): + listener.exitNumericLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNumericLiteral" ): + return visitor.visitNumericLiteral(self) + else: + return visitor.visitChildren(self) + + + + + def numericLiteral(self): + + localctx = FuncTestCaseParser.NumericLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 20, self.RULE_numericLiteral) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 164 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 114688) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NullArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def NULL_LITERAL(self): + return self.getToken(FuncTestCaseParser.NULL_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def datatype(self): + return self.getTypedRuleContext(FuncTestCaseParser.DatatypeContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_nullArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterNullArg" ): + listener.enterNullArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitNullArg" ): + listener.exitNullArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitNullArg" ): + return visitor.visitNullArg(self) + else: + return visitor.visitChildren(self) + + + + + def nullArg(self): + + localctx = FuncTestCaseParser.NullArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 22, self.RULE_nullArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 166 + self.match(FuncTestCaseParser.NULL_LITERAL) + self.state = 167 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 168 + self.datatype() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I8ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def I8(self): + return self.getToken(FuncTestCaseParser.I8, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_i8Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI8Arg" ): + listener.enterI8Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI8Arg" ): + listener.exitI8Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI8Arg" ): + return visitor.visitI8Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i8Arg(self): + + localctx = FuncTestCaseParser.I8ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 24, self.RULE_i8Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 170 + self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 171 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 172 + self.match(FuncTestCaseParser.I8) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I16ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def I16(self): + return self.getToken(FuncTestCaseParser.I16, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_i16Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI16Arg" ): + listener.enterI16Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI16Arg" ): + listener.exitI16Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI16Arg" ): + return visitor.visitI16Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i16Arg(self): + + localctx = FuncTestCaseParser.I16ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 26, self.RULE_i16Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 174 + self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 175 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 176 + self.match(FuncTestCaseParser.I16) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I32ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def I32(self): + return self.getToken(FuncTestCaseParser.I32, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_i32Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI32Arg" ): + listener.enterI32Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI32Arg" ): + listener.exitI32Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI32Arg" ): + return visitor.visitI32Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i32Arg(self): + + localctx = FuncTestCaseParser.I32ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 28, self.RULE_i32Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 178 + self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 179 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 180 + self.match(FuncTestCaseParser.I32) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class I64ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTEGER_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def I64(self): + return self.getToken(FuncTestCaseParser.I64, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_i64Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI64Arg" ): + listener.enterI64Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI64Arg" ): + listener.exitI64Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI64Arg" ): + return visitor.visitI64Arg(self) + else: + return visitor.visitChildren(self) + + + + + def i64Arg(self): + + localctx = FuncTestCaseParser.I64ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 30, self.RULE_i64Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 182 + self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 183 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 184 + self.match(FuncTestCaseParser.I64) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Fp32ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def numericLiteral(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext,0) + + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def FP32(self): + return self.getToken(FuncTestCaseParser.FP32, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_fp32Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp32Arg" ): + listener.enterFp32Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp32Arg" ): + listener.exitFp32Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp32Arg" ): + return visitor.visitFp32Arg(self) + else: + return visitor.visitChildren(self) + + + + + def fp32Arg(self): + + localctx = FuncTestCaseParser.Fp32ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 32, self.RULE_fp32Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 186 + self.numericLiteral() + self.state = 187 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 188 + self.match(FuncTestCaseParser.FP32) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Fp64ArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def numericLiteral(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext,0) + + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def FP64(self): + return self.getToken(FuncTestCaseParser.FP64, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_fp64Arg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp64Arg" ): + listener.enterFp64Arg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp64Arg" ): + listener.exitFp64Arg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp64Arg" ): + return visitor.visitFp64Arg(self) + else: + return visitor.visitChildren(self) + + + + + def fp64Arg(self): + + localctx = FuncTestCaseParser.Fp64ArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 34, self.RULE_fp64Arg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 190 + self.numericLiteral() + self.state = 191 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 192 + self.match(FuncTestCaseParser.FP64) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DecimalArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def numericLiteral(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext,0) + + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def decimalType(self): + return self.getTypedRuleContext(FuncTestCaseParser.DecimalTypeContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_decimalArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDecimalArg" ): + listener.enterDecimalArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDecimalArg" ): + listener.exitDecimalArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDecimalArg" ): + return visitor.visitDecimalArg(self) + else: + return visitor.visitChildren(self) + + + + + def decimalArg(self): + + localctx = FuncTestCaseParser.DecimalArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 36, self.RULE_decimalArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 194 + self.numericLiteral() + self.state = 195 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 196 + self.decimalType() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class BooleanArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BOOLEAN_LITERAL(self): + return self.getToken(FuncTestCaseParser.BOOLEAN_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def Bool(self): + return self.getToken(FuncTestCaseParser.Bool, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_booleanArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBooleanArg" ): + listener.enterBooleanArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBooleanArg" ): + listener.exitBooleanArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBooleanArg" ): + return visitor.visitBooleanArg(self) + else: + return visitor.visitChildren(self) + + + + + def booleanArg(self): + + localctx = FuncTestCaseParser.BooleanArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 38, self.RULE_booleanArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 198 + self.match(FuncTestCaseParser.BOOLEAN_LITERAL) + self.state = 199 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 200 + self.match(FuncTestCaseParser.Bool) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class StringArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def STRING_LITERAL(self): + return self.getToken(FuncTestCaseParser.STRING_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def Str(self): + return self.getToken(FuncTestCaseParser.Str, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_stringArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterStringArg" ): + listener.enterStringArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitStringArg" ): + listener.exitStringArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitStringArg" ): + return visitor.visitStringArg(self) + else: + return visitor.visitChildren(self) + + + + + def stringArg(self): + + localctx = FuncTestCaseParser.StringArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 40, self.RULE_stringArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 202 + self.match(FuncTestCaseParser.STRING_LITERAL) + self.state = 203 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 204 + self.match(FuncTestCaseParser.Str) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DateArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DATE_LITERAL(self): + return self.getToken(FuncTestCaseParser.DATE_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def Date(self): + return self.getToken(FuncTestCaseParser.Date, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_dateArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDateArg" ): + listener.enterDateArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDateArg" ): + listener.exitDateArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDateArg" ): + return visitor.visitDateArg(self) + else: + return visitor.visitChildren(self) + + + + + def dateArg(self): + + localctx = FuncTestCaseParser.DateArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 42, self.RULE_dateArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 206 + self.match(FuncTestCaseParser.DATE_LITERAL) + self.state = 207 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 208 + self.match(FuncTestCaseParser.Date) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimeArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TIME_LITERAL(self): + return self.getToken(FuncTestCaseParser.TIME_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def Time(self): + return self.getToken(FuncTestCaseParser.Time, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_timeArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeArg" ): + listener.enterTimeArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeArg" ): + listener.exitTimeArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeArg" ): + return visitor.visitTimeArg(self) + else: + return visitor.visitChildren(self) + + + + + def timeArg(self): + + localctx = FuncTestCaseParser.TimeArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 44, self.RULE_timeArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 210 + self.match(FuncTestCaseParser.TIME_LITERAL) + self.state = 211 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 212 + self.match(FuncTestCaseParser.Time) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimestampArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TIMESTAMP_LITERAL(self): + return self.getToken(FuncTestCaseParser.TIMESTAMP_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def Ts(self): + return self.getToken(FuncTestCaseParser.Ts, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_timestampArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestampArg" ): + listener.enterTimestampArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestampArg" ): + listener.exitTimestampArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestampArg" ): + return visitor.visitTimestampArg(self) + else: + return visitor.visitChildren(self) + + + + + def timestampArg(self): + + localctx = FuncTestCaseParser.TimestampArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 46, self.RULE_timestampArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 214 + self.match(FuncTestCaseParser.TIMESTAMP_LITERAL) + self.state = 215 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 216 + self.match(FuncTestCaseParser.Ts) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimestampTzArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def TIMESTAMP_TZ_LITERAL(self): + return self.getToken(FuncTestCaseParser.TIMESTAMP_TZ_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def TsTZ(self): + return self.getToken(FuncTestCaseParser.TsTZ, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_timestampTzArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestampTzArg" ): + listener.enterTimestampTzArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestampTzArg" ): + listener.exitTimestampTzArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestampTzArg" ): + return visitor.visitTimestampTzArg(self) + else: + return visitor.visitChildren(self) + + + + + def timestampTzArg(self): + + localctx = FuncTestCaseParser.TimestampTzArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 48, self.RULE_timestampTzArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 218 + self.match(FuncTestCaseParser.TIMESTAMP_TZ_LITERAL) + self.state = 219 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 220 + self.match(FuncTestCaseParser.TsTZ) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalYearArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTERVAL_YEAR_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTERVAL_YEAR_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def IYear(self): + return self.getToken(FuncTestCaseParser.IYear, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_intervalYearArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalYearArg" ): + listener.enterIntervalYearArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalYearArg" ): + listener.exitIntervalYearArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalYearArg" ): + return visitor.visitIntervalYearArg(self) + else: + return visitor.visitChildren(self) + + + + + def intervalYearArg(self): + + localctx = FuncTestCaseParser.IntervalYearArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 50, self.RULE_intervalYearArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 222 + self.match(FuncTestCaseParser.INTERVAL_YEAR_LITERAL) + self.state = 223 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 224 + self.match(FuncTestCaseParser.IYear) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalDayArgContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def INTERVAL_DAY_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTERVAL_DAY_LITERAL, 0) + + def DOUBLE_COLON(self): + return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) + + def IDay(self): + return self.getToken(FuncTestCaseParser.IDay, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_intervalDayArg + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalDayArg" ): + listener.enterIntervalDayArg(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalDayArg" ): + listener.exitIntervalDayArg(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalDayArg" ): + return visitor.visitIntervalDayArg(self) + else: + return visitor.visitChildren(self) + + + + + def intervalDayArg(self): + + localctx = FuncTestCaseParser.IntervalDayArgContext(self, self._ctx, self.state) + self.enterRule(localctx, 52, self.RULE_intervalDayArg) + try: + self.enterOuterAlt(localctx, 1) + self.state = 226 + self.match(FuncTestCaseParser.INTERVAL_DAY_LITERAL) + self.state = 227 + self.match(FuncTestCaseParser.DOUBLE_COLON) + self.state = 228 + self.match(FuncTestCaseParser.IDay) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalYearLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.years = None # Token + self.months = None # Token + + def PERIOD_PREFIX(self): + return self.getToken(FuncTestCaseParser.PERIOD_PREFIX, 0) + + def YEAR_SUFFIX(self): + return self.getToken(FuncTestCaseParser.YEAR_SUFFIX, 0) + + def INTEGER_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(FuncTestCaseParser.INTEGER_LITERAL) + else: + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, i) + + def M_SUFFIX(self): + return self.getToken(FuncTestCaseParser.M_SUFFIX, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_intervalYearLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalYearLiteral" ): + listener.enterIntervalYearLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalYearLiteral" ): + listener.exitIntervalYearLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalYearLiteral" ): + return visitor.visitIntervalYearLiteral(self) + else: + return visitor.visitChildren(self) + + + + + def intervalYearLiteral(self): + + localctx = FuncTestCaseParser.IntervalYearLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 54, self.RULE_intervalYearLiteral) + self._la = 0 # Token type + try: + self.state = 241 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,8,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 230 + self.match(FuncTestCaseParser.PERIOD_PREFIX) + + self.state = 231 + localctx.years = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 232 + self.match(FuncTestCaseParser.YEAR_SUFFIX) + self.state = 236 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 234 + localctx.months = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 235 + self.match(FuncTestCaseParser.M_SUFFIX) + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 238 + self.match(FuncTestCaseParser.PERIOD_PREFIX) + + self.state = 239 + localctx.months = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 240 + self.match(FuncTestCaseParser.M_SUFFIX) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class IntervalDayLiteralContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.days = None # Token + + def PERIOD_PREFIX(self): + return self.getToken(FuncTestCaseParser.PERIOD_PREFIX, 0) + + def DAY_SUFFIX(self): + return self.getToken(FuncTestCaseParser.DAY_SUFFIX, 0) + + def INTEGER_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) + + def TIME_PREFIX(self): + return self.getToken(FuncTestCaseParser.TIME_PREFIX, 0) + + def timeInterval(self): + return self.getTypedRuleContext(FuncTestCaseParser.TimeIntervalContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_intervalDayLiteral + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalDayLiteral" ): + listener.enterIntervalDayLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalDayLiteral" ): + listener.exitIntervalDayLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalDayLiteral" ): + return visitor.visitIntervalDayLiteral(self) + else: + return visitor.visitChildren(self) + + + + + def intervalDayLiteral(self): + + localctx = FuncTestCaseParser.IntervalDayLiteralContext(self, self._ctx, self.state) + self.enterRule(localctx, 56, self.RULE_intervalDayLiteral) + self._la = 0 # Token type + try: + self.state = 254 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,10,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 243 + self.match(FuncTestCaseParser.PERIOD_PREFIX) + + self.state = 244 + localctx.days = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 245 + self.match(FuncTestCaseParser.DAY_SUFFIX) + self.state = 249 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==23: + self.state = 247 + self.match(FuncTestCaseParser.TIME_PREFIX) + self.state = 248 + self.timeInterval() + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 251 + self.match(FuncTestCaseParser.PERIOD_PREFIX) + self.state = 252 + self.match(FuncTestCaseParser.TIME_PREFIX) + self.state = 253 + self.timeInterval() + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class TimeIntervalContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + self.hours = None # Token + self.minutes = None # Token + self.seconds = None # Token + self.fractionalSeconds = None # Token + + def HOUR_SUFFIX(self): + return self.getToken(FuncTestCaseParser.HOUR_SUFFIX, 0) + + def INTEGER_LITERAL(self, i:int=None): + if i is None: + return self.getTokens(FuncTestCaseParser.INTEGER_LITERAL) + else: + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, i) + + def M_SUFFIX(self): + return self.getToken(FuncTestCaseParser.M_SUFFIX, 0) + + def SECOND_SUFFIX(self): + return self.getToken(FuncTestCaseParser.SECOND_SUFFIX, 0) + + def FRACTIONAL_SECOND_SUFFIX(self): + return self.getToken(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_timeInterval + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimeInterval" ): + listener.enterTimeInterval(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimeInterval" ): + listener.exitTimeInterval(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimeInterval" ): + return visitor.visitTimeInterval(self) + else: + return visitor.visitChildren(self) + + + + + def timeInterval(self): + + localctx = FuncTestCaseParser.TimeIntervalContext(self, self._ctx, self.state) + self.enterRule(localctx, 58, self.RULE_timeInterval) + self._la = 0 # Token type + try: + self.state = 288 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,17,self._ctx) + if la_ == 1: + self.enterOuterAlt(localctx, 1) + self.state = 256 + localctx.hours = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 257 + self.match(FuncTestCaseParser.HOUR_SUFFIX) + self.state = 260 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,11,self._ctx) + if la_ == 1: + self.state = 258 + localctx.minutes = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 259 + self.match(FuncTestCaseParser.M_SUFFIX) + + + self.state = 264 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,12,self._ctx) + if la_ == 1: + self.state = 262 + localctx.seconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 263 + self.match(FuncTestCaseParser.SECOND_SUFFIX) + + + self.state = 268 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 266 + localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 267 + self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) + + + pass + + elif la_ == 2: + self.enterOuterAlt(localctx, 2) + self.state = 270 + localctx.minutes = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 271 + self.match(FuncTestCaseParser.M_SUFFIX) + self.state = 274 + self._errHandler.sync(self) + la_ = self._interp.adaptivePredict(self._input,14,self._ctx) + if la_ == 1: + self.state = 272 + localctx.seconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 273 + self.match(FuncTestCaseParser.SECOND_SUFFIX) + + + self.state = 278 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 276 + localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 277 + self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) + + + pass + + elif la_ == 3: + self.enterOuterAlt(localctx, 3) + self.state = 280 + localctx.seconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 281 + self.match(FuncTestCaseParser.SECOND_SUFFIX) + self.state = 284 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==14: + self.state = 282 + localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 283 + self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) + + + pass + + elif la_ == 4: + self.enterOuterAlt(localctx, 4) + self.state = 286 + localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + self.state = 287 + self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) + pass + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DatatypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def scalarType(self): + return self.getTypedRuleContext(FuncTestCaseParser.ScalarTypeContext,0) + + + def parameterizedType(self): + return self.getTypedRuleContext(FuncTestCaseParser.ParameterizedTypeContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_datatype + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDatatype" ): + listener.enterDatatype(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDatatype" ): + listener.exitDatatype(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDatatype" ): + return visitor.visitDatatype(self) + else: + return visitor.visitChildren(self) + + + + + def datatype(self): + + localctx = FuncTestCaseParser.DatatypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 60, self.RULE_datatype) + try: + self.state = 292 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [41, 42, 43, 44, 45, 46, 48, 51, 52, 55, 67, 69, 70, 72, 73, 74, 75]: + self.enterOuterAlt(localctx, 1) + self.state = 290 + self.scalarType() + pass + elif token in [76, 77, 78, 79, 80, 81]: + self.enterOuterAlt(localctx, 2) + self.state = 291 + self.parameterizedType() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ScalarTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_scalarType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class DateContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Date(self): + return self.getToken(FuncTestCaseParser.Date, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDate" ): + listener.enterDate(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDate" ): + listener.exitDate(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDate" ): + return visitor.visitDate(self) + else: + return visitor.visitChildren(self) + + + class StringContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Str(self): + return self.getToken(FuncTestCaseParser.Str, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterString" ): + listener.enterString(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitString" ): + listener.exitString(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitString" ): + return visitor.visitString(self) + else: + return visitor.visitChildren(self) + + + class I64Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I64(self): + return self.getToken(FuncTestCaseParser.I64, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI64" ): + listener.enterI64(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI64" ): + listener.exitI64(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI64" ): + return visitor.visitI64(self) + else: + return visitor.visitChildren(self) + + + class UserDefinedContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def UserDefined(self): + return self.getToken(FuncTestCaseParser.UserDefined, 0) + def IDENTIFIER(self): + return self.getToken(FuncTestCaseParser.IDENTIFIER, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUserDefined" ): + listener.enterUserDefined(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUserDefined" ): + listener.exitUserDefined(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUserDefined" ): + return visitor.visitUserDefined(self) + else: + return visitor.visitChildren(self) + + + class I32Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I32(self): + return self.getToken(FuncTestCaseParser.I32, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI32" ): + listener.enterI32(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI32" ): + listener.exitI32(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI32" ): + return visitor.visitI32(self) + else: + return visitor.visitChildren(self) + + + class IntervalYearContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def IYear(self): + return self.getToken(FuncTestCaseParser.IYear, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalYear" ): + listener.enterIntervalYear(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalYear" ): + listener.exitIntervalYear(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalYear" ): + return visitor.visitIntervalYear(self) + else: + return visitor.visitChildren(self) + + + class UuidContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def UUID(self): + return self.getToken(FuncTestCaseParser.UUID, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterUuid" ): + listener.enterUuid(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitUuid" ): + listener.exitUuid(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitUuid" ): + return visitor.visitUuid(self) + else: + return visitor.visitChildren(self) + + + class I8Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I8(self): + return self.getToken(FuncTestCaseParser.I8, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI8" ): + listener.enterI8(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI8" ): + listener.exitI8(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI8" ): + return visitor.visitI8(self) + else: + return visitor.visitChildren(self) + + + class I16Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def I16(self): + return self.getToken(FuncTestCaseParser.I16, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterI16" ): + listener.enterI16(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitI16" ): + listener.exitI16(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitI16" ): + return visitor.visitI16(self) + else: + return visitor.visitChildren(self) + + + class BinaryContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Binary(self): + return self.getToken(FuncTestCaseParser.Binary, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBinary" ): + listener.enterBinary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBinary" ): + listener.exitBinary(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBinary" ): + return visitor.visitBinary(self) + else: + return visitor.visitChildren(self) + + + class IntervalDayContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def IDay(self): + return self.getToken(FuncTestCaseParser.IDay, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntervalDay" ): + listener.enterIntervalDay(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntervalDay" ): + listener.exitIntervalDay(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntervalDay" ): + return visitor.visitIntervalDay(self) + else: + return visitor.visitChildren(self) + + + class Fp64Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def FP64(self): + return self.getToken(FuncTestCaseParser.FP64, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp64" ): + listener.enterFp64(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp64" ): + listener.exitFp64(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp64" ): + return visitor.visitFp64(self) + else: + return visitor.visitChildren(self) + + + class Fp32Context(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def FP32(self): + return self.getToken(FuncTestCaseParser.FP32, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFp32" ): + listener.enterFp32(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFp32" ): + listener.exitFp32(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFp32" ): + return visitor.visitFp32(self) + else: + return visitor.visitChildren(self) + + + class TimeContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Time(self): + return self.getToken(FuncTestCaseParser.Time, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTime" ): + listener.enterTime(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTime" ): + listener.exitTime(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTime" ): + return visitor.visitTime(self) + else: + return visitor.visitChildren(self) + + + class BooleanContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Bool(self): + return self.getToken(FuncTestCaseParser.Bool, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBoolean" ): + listener.enterBoolean(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBoolean" ): + listener.exitBoolean(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitBoolean" ): + return visitor.visitBoolean(self) + else: + return visitor.visitChildren(self) + + + class TimestampContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def Ts(self): + return self.getToken(FuncTestCaseParser.Ts, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestamp" ): + listener.enterTimestamp(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestamp" ): + listener.exitTimestamp(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestamp" ): + return visitor.visitTimestamp(self) + else: + return visitor.visitChildren(self) + + + class TimestampTzContext(ScalarTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + super().__init__(parser) + self.copyFrom(ctx) + + def TsTZ(self): + return self.getToken(FuncTestCaseParser.TsTZ, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterTimestampTz" ): + listener.enterTimestampTz(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitTimestampTz" ): + listener.exitTimestampTz(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitTimestampTz" ): + return visitor.visitTimestampTz(self) + else: + return visitor.visitChildren(self) + + + + def scalarType(self): + + localctx = FuncTestCaseParser.ScalarTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 62, self.RULE_scalarType) + try: + self.state = 312 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [69]: + localctx = FuncTestCaseParser.BooleanContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 294 + self.match(FuncTestCaseParser.Bool) + pass + elif token in [41]: + localctx = FuncTestCaseParser.I8Context(self, localctx) + self.enterOuterAlt(localctx, 2) + self.state = 295 + self.match(FuncTestCaseParser.I8) + pass + elif token in [42]: + localctx = FuncTestCaseParser.I16Context(self, localctx) + self.enterOuterAlt(localctx, 3) + self.state = 296 + self.match(FuncTestCaseParser.I16) + pass + elif token in [43]: + localctx = FuncTestCaseParser.I32Context(self, localctx) + self.enterOuterAlt(localctx, 4) + self.state = 297 + self.match(FuncTestCaseParser.I32) + pass + elif token in [44]: + localctx = FuncTestCaseParser.I64Context(self, localctx) + self.enterOuterAlt(localctx, 5) + self.state = 298 + self.match(FuncTestCaseParser.I64) + pass + elif token in [45]: + localctx = FuncTestCaseParser.Fp32Context(self, localctx) + self.enterOuterAlt(localctx, 6) + self.state = 299 + self.match(FuncTestCaseParser.FP32) + pass + elif token in [46]: + localctx = FuncTestCaseParser.Fp64Context(self, localctx) + self.enterOuterAlt(localctx, 7) + self.state = 300 + self.match(FuncTestCaseParser.FP64) + pass + elif token in [70]: + localctx = FuncTestCaseParser.StringContext(self, localctx) + self.enterOuterAlt(localctx, 8) + self.state = 301 + self.match(FuncTestCaseParser.Str) + pass + elif token in [48]: + localctx = FuncTestCaseParser.BinaryContext(self, localctx) + self.enterOuterAlt(localctx, 9) + self.state = 302 + self.match(FuncTestCaseParser.Binary) + pass + elif token in [72]: + localctx = FuncTestCaseParser.TimestampContext(self, localctx) + self.enterOuterAlt(localctx, 10) + self.state = 303 + self.match(FuncTestCaseParser.Ts) + pass + elif token in [73]: + localctx = FuncTestCaseParser.TimestampTzContext(self, localctx) + self.enterOuterAlt(localctx, 11) + self.state = 304 + self.match(FuncTestCaseParser.TsTZ) + pass + elif token in [51]: + localctx = FuncTestCaseParser.DateContext(self, localctx) + self.enterOuterAlt(localctx, 12) + self.state = 305 + self.match(FuncTestCaseParser.Date) + pass + elif token in [52]: + localctx = FuncTestCaseParser.TimeContext(self, localctx) + self.enterOuterAlt(localctx, 13) + self.state = 306 + self.match(FuncTestCaseParser.Time) + pass + elif token in [75]: + localctx = FuncTestCaseParser.IntervalDayContext(self, localctx) + self.enterOuterAlt(localctx, 14) + self.state = 307 + self.match(FuncTestCaseParser.IDay) + pass + elif token in [74]: + localctx = FuncTestCaseParser.IntervalYearContext(self, localctx) + self.enterOuterAlt(localctx, 15) + self.state = 308 + self.match(FuncTestCaseParser.IYear) + pass + elif token in [55]: + localctx = FuncTestCaseParser.UuidContext(self, localctx) + self.enterOuterAlt(localctx, 16) + self.state = 309 + self.match(FuncTestCaseParser.UUID) + pass + elif token in [67]: + localctx = FuncTestCaseParser.UserDefinedContext(self, localctx) + self.enterOuterAlt(localctx, 17) + self.state = 310 + self.match(FuncTestCaseParser.UserDefined) + self.state = 311 + self.match(FuncTestCaseParser.IDENTIFIER) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FixedCharTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_fixedCharType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class FixedCharContext(FixedCharTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.FixedCharTypeContext + super().__init__(parser) + self.isnull = None # Token + self.len_ = None # NumericParameterContext + self.copyFrom(ctx) + + def FChar(self): + return self.getToken(FuncTestCaseParser.FChar, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(FuncTestCaseParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFixedChar" ): + listener.enterFixedChar(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFixedChar" ): + listener.exitFixedChar(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFixedChar" ): + return visitor.visitFixedChar(self) + else: + return visitor.visitChildren(self) + + + + def fixedCharType(self): + + localctx = FuncTestCaseParser.FixedCharTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 64, self.RULE_fixedCharType) + self._la = 0 # Token type + try: + localctx = FuncTestCaseParser.FixedCharContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 314 + self.match(FuncTestCaseParser.FChar) + self.state = 316 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==93: + self.state = 315 + localctx.isnull = self.match(FuncTestCaseParser.QMARK) + + + self.state = 318 + self.match(FuncTestCaseParser.O_ANGLE_BRACKET) + self.state = 319 + localctx.len_ = self.numericParameter() + self.state = 320 + self.match(FuncTestCaseParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class VarCharTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_varCharType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class VarCharContext(VarCharTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.VarCharTypeContext + super().__init__(parser) + self.isnull = None # Token + self.len_ = None # NumericParameterContext + self.copyFrom(ctx) + + def VChar(self): + return self.getToken(FuncTestCaseParser.VChar, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(FuncTestCaseParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterVarChar" ): + listener.enterVarChar(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitVarChar" ): + listener.exitVarChar(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitVarChar" ): + return visitor.visitVarChar(self) + else: + return visitor.visitChildren(self) + + + + def varCharType(self): + + localctx = FuncTestCaseParser.VarCharTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 66, self.RULE_varCharType) + self._la = 0 # Token type + try: + localctx = FuncTestCaseParser.VarCharContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 322 + self.match(FuncTestCaseParser.VChar) + self.state = 324 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==93: + self.state = 323 + localctx.isnull = self.match(FuncTestCaseParser.QMARK) + + + self.state = 326 + self.match(FuncTestCaseParser.O_ANGLE_BRACKET) + self.state = 327 + localctx.len_ = self.numericParameter() + self.state = 328 + self.match(FuncTestCaseParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class FixedBinaryTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_fixedBinaryType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class FixedBinaryContext(FixedBinaryTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.FixedBinaryTypeContext + super().__init__(parser) + self.isnull = None # Token + self.len_ = None # NumericParameterContext + self.copyFrom(ctx) + + def FBin(self): + return self.getToken(FuncTestCaseParser.FBin, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(FuncTestCaseParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFixedBinary" ): + listener.enterFixedBinary(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFixedBinary" ): + listener.exitFixedBinary(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFixedBinary" ): + return visitor.visitFixedBinary(self) + else: + return visitor.visitChildren(self) + + + + def fixedBinaryType(self): + + localctx = FuncTestCaseParser.FixedBinaryTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 68, self.RULE_fixedBinaryType) + self._la = 0 # Token type + try: + localctx = FuncTestCaseParser.FixedBinaryContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 330 + self.match(FuncTestCaseParser.FBin) + self.state = 332 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==93: + self.state = 331 + localctx.isnull = self.match(FuncTestCaseParser.QMARK) + + + self.state = 334 + self.match(FuncTestCaseParser.O_ANGLE_BRACKET) + self.state = 335 + localctx.len_ = self.numericParameter() + self.state = 336 + self.match(FuncTestCaseParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class DecimalTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_decimalType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class DecimalContext(DecimalTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.DecimalTypeContext + super().__init__(parser) + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.scale = None # NumericParameterContext + self.copyFrom(ctx) + + def Dec(self): + return self.getToken(FuncTestCaseParser.Dec, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def COMMA(self): + return self.getToken(FuncTestCaseParser.COMMA, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def QMARK(self): + return self.getToken(FuncTestCaseParser.QMARK, 0) + def numericParameter(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.NumericParameterContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,i) + + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterDecimal" ): + listener.enterDecimal(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitDecimal" ): + listener.exitDecimal(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitDecimal" ): + return visitor.visitDecimal(self) + else: + return visitor.visitChildren(self) + + + + def decimalType(self): + + localctx = FuncTestCaseParser.DecimalTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 70, self.RULE_decimalType) + self._la = 0 # Token type + try: + localctx = FuncTestCaseParser.DecimalContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 338 + self.match(FuncTestCaseParser.Dec) + self.state = 340 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==93: + self.state = 339 + localctx.isnull = self.match(FuncTestCaseParser.QMARK) + + + self.state = 348 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==84: + self.state = 342 + self.match(FuncTestCaseParser.O_ANGLE_BRACKET) + self.state = 343 + localctx.precision = self.numericParameter() + self.state = 344 + self.match(FuncTestCaseParser.COMMA) + self.state = 345 + localctx.scale = self.numericParameter() + self.state = 346 + self.match(FuncTestCaseParser.C_ANGLE_BRACKET) + + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PrecisionTimestampTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_precisionTimestampType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class PrecisionTimestampContext(PrecisionTimestampTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.PrecisionTimestampTypeContext + super().__init__(parser) + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.copyFrom(ctx) + + def PTs(self): + return self.getToken(FuncTestCaseParser.PTs, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(FuncTestCaseParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPrecisionTimestamp" ): + listener.enterPrecisionTimestamp(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPrecisionTimestamp" ): + listener.exitPrecisionTimestamp(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPrecisionTimestamp" ): + return visitor.visitPrecisionTimestamp(self) + else: + return visitor.visitChildren(self) + + + + def precisionTimestampType(self): + + localctx = FuncTestCaseParser.PrecisionTimestampTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 72, self.RULE_precisionTimestampType) + self._la = 0 # Token type + try: + localctx = FuncTestCaseParser.PrecisionTimestampContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 350 + self.match(FuncTestCaseParser.PTs) + self.state = 352 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==93: + self.state = 351 + localctx.isnull = self.match(FuncTestCaseParser.QMARK) + + + self.state = 354 + self.match(FuncTestCaseParser.O_ANGLE_BRACKET) + self.state = 355 + localctx.precision = self.numericParameter() + self.state = 356 + self.match(FuncTestCaseParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class PrecisionTimestampTZTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_precisionTimestampTZType + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class PrecisionTimestampTZContext(PrecisionTimestampTZTypeContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.PrecisionTimestampTZTypeContext + super().__init__(parser) + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.copyFrom(ctx) + + def PTsTZ(self): + return self.getToken(FuncTestCaseParser.PTsTZ, 0) + def O_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): + return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): + return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + + def QMARK(self): + return self.getToken(FuncTestCaseParser.QMARK, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterPrecisionTimestampTZ" ): + listener.enterPrecisionTimestampTZ(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitPrecisionTimestampTZ" ): + listener.exitPrecisionTimestampTZ(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitPrecisionTimestampTZ" ): + return visitor.visitPrecisionTimestampTZ(self) + else: + return visitor.visitChildren(self) + + + + def precisionTimestampTZType(self): + + localctx = FuncTestCaseParser.PrecisionTimestampTZTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 74, self.RULE_precisionTimestampTZType) + self._la = 0 # Token type + try: + localctx = FuncTestCaseParser.PrecisionTimestampTZContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 358 + self.match(FuncTestCaseParser.PTsTZ) + self.state = 360 + self._errHandler.sync(self) + _la = self._input.LA(1) + if _la==93: + self.state = 359 + localctx.isnull = self.match(FuncTestCaseParser.QMARK) + + + self.state = 362 + self.match(FuncTestCaseParser.O_ANGLE_BRACKET) + self.state = 363 + localctx.precision = self.numericParameter() + self.state = 364 + self.match(FuncTestCaseParser.C_ANGLE_BRACKET) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class ParameterizedTypeContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def fixedCharType(self): + return self.getTypedRuleContext(FuncTestCaseParser.FixedCharTypeContext,0) + + + def varCharType(self): + return self.getTypedRuleContext(FuncTestCaseParser.VarCharTypeContext,0) + + + def fixedBinaryType(self): + return self.getTypedRuleContext(FuncTestCaseParser.FixedBinaryTypeContext,0) + + + def decimalType(self): + return self.getTypedRuleContext(FuncTestCaseParser.DecimalTypeContext,0) + + + def precisionTimestampType(self): + return self.getTypedRuleContext(FuncTestCaseParser.PrecisionTimestampTypeContext,0) + + + def precisionTimestampTZType(self): + return self.getTypedRuleContext(FuncTestCaseParser.PrecisionTimestampTZTypeContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_parameterizedType + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParameterizedType" ): + listener.enterParameterizedType(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParameterizedType" ): + listener.exitParameterizedType(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitParameterizedType" ): + return visitor.visitParameterizedType(self) + else: + return visitor.visitChildren(self) + + + + + def parameterizedType(self): + + localctx = FuncTestCaseParser.ParameterizedTypeContext(self, self._ctx, self.state) + self.enterRule(localctx, 76, self.RULE_parameterizedType) + try: + self.state = 372 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [79]: + self.enterOuterAlt(localctx, 1) + self.state = 366 + self.fixedCharType() + pass + elif token in [80]: + self.enterOuterAlt(localctx, 2) + self.state = 367 + self.varCharType() + pass + elif token in [81]: + self.enterOuterAlt(localctx, 3) + self.state = 368 + self.fixedBinaryType() + pass + elif token in [76]: + self.enterOuterAlt(localctx, 4) + self.state = 369 + self.decimalType() + pass + elif token in [77]: + self.enterOuterAlt(localctx, 5) + self.state = 370 + self.precisionTimestampType() + pass + elif token in [78]: + self.enterOuterAlt(localctx, 6) + self.state = 371 + self.precisionTimestampTZType() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class NumericParameterContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_numericParameter + + + def copyFrom(self, ctx:ParserRuleContext): + super().copyFrom(ctx) + + + + class IntegerLiteralContext(NumericParameterContext): + + def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.NumericParameterContext + super().__init__(parser) + self.copyFrom(ctx) + + def INTEGER_LITERAL(self): + return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterIntegerLiteral" ): + listener.enterIntegerLiteral(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitIntegerLiteral" ): + listener.exitIntegerLiteral(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitIntegerLiteral" ): + return visitor.visitIntegerLiteral(self) + else: + return visitor.visitChildren(self) + + + + def numericParameter(self): + + localctx = FuncTestCaseParser.NumericParameterContext(self, self._ctx, self.state) + self.enterRule(localctx, 78, self.RULE_numericParameter) + try: + localctx = FuncTestCaseParser.IntegerLiteralContext(self, localctx) + self.enterOuterAlt(localctx, 1) + self.state = 374 + self.match(FuncTestCaseParser.INTEGER_LITERAL) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class SubstraitErrorContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ERROR_RESULT(self): + return self.getToken(FuncTestCaseParser.ERROR_RESULT, 0) + + def UNDEFINED_RESULT(self): + return self.getToken(FuncTestCaseParser.UNDEFINED_RESULT, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_substraitError + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSubstraitError" ): + listener.enterSubstraitError(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSubstraitError" ): + listener.exitSubstraitError(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitSubstraitError" ): + return visitor.visitSubstraitError(self) + else: + return visitor.visitChildren(self) + + + + + def substraitError(self): + + localctx = FuncTestCaseParser.SubstraitErrorContext(self, self._ctx, self.state) + self.enterRule(localctx, 80, self.RULE_substraitError) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 376 + _la = self._input.LA(1) + if not(_la==5 or _la==6): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Func_optionContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def option_name(self): + return self.getTypedRuleContext(FuncTestCaseParser.Option_nameContext,0) + + + def COLON(self): + return self.getToken(FuncTestCaseParser.COLON, 0) + + def option_value(self): + return self.getTypedRuleContext(FuncTestCaseParser.Option_valueContext,0) + + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_func_option + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunc_option" ): + listener.enterFunc_option(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunc_option" ): + listener.exitFunc_option(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFunc_option" ): + return visitor.visitFunc_option(self) + else: + return visitor.visitChildren(self) + + + + + def func_option(self): + + localctx = FuncTestCaseParser.Func_optionContext(self, self._ctx, self.state) + self.enterRule(localctx, 82, self.RULE_func_option) + try: + self.enterOuterAlt(localctx, 1) + self.state = 378 + self.option_name() + self.state = 379 + self.match(FuncTestCaseParser.COLON) + self.state = 380 + self.option_value() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Option_nameContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def OVERFLOW(self): + return self.getToken(FuncTestCaseParser.OVERFLOW, 0) + + def ROUNDING(self): + return self.getToken(FuncTestCaseParser.ROUNDING, 0) + + def IDENTIFIER(self): + return self.getToken(FuncTestCaseParser.IDENTIFIER, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_option_name + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOption_name" ): + listener.enterOption_name(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOption_name" ): + listener.exitOption_name(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOption_name" ): + return visitor.visitOption_name(self) + else: + return visitor.visitChildren(self) + + + + + def option_name(self): + + localctx = FuncTestCaseParser.Option_nameContext(self, self._ctx, self.state) + self.enterRule(localctx, 84, self.RULE_option_name) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 382 + _la = self._input.LA(1) + if not(_la==7 or _la==8 or _la==83): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Option_valueContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ERROR(self): + return self.getToken(FuncTestCaseParser.ERROR, 0) + + def SATURATE(self): + return self.getToken(FuncTestCaseParser.SATURATE, 0) + + def SILENT(self): + return self.getToken(FuncTestCaseParser.SILENT, 0) + + def TIE_TO_EVEN(self): + return self.getToken(FuncTestCaseParser.TIE_TO_EVEN, 0) + + def NAN(self): + return self.getToken(FuncTestCaseParser.NAN, 0) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_option_value + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterOption_value" ): + listener.enterOption_value(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitOption_value" ): + listener.exitOption_value(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitOption_value" ): + return visitor.visitOption_value(self) + else: + return visitor.visitChildren(self) + + + + + def option_value(self): + + localctx = FuncTestCaseParser.Option_valueContext(self, self._ctx, self.state) + self.enterRule(localctx, 86, self.RULE_option_value) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 384 + _la = self._input.LA(1) + if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 15872) != 0)): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + class Func_optionsContext(ParserRuleContext): + __slots__ = 'parser' + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def func_option(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(FuncTestCaseParser.Func_optionContext) + else: + return self.getTypedRuleContext(FuncTestCaseParser.Func_optionContext,i) + + + def COMMA(self, i:int=None): + if i is None: + return self.getTokens(FuncTestCaseParser.COMMA) + else: + return self.getToken(FuncTestCaseParser.COMMA, i) + + def getRuleIndex(self): + return FuncTestCaseParser.RULE_func_options + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterFunc_options" ): + listener.enterFunc_options(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitFunc_options" ): + listener.exitFunc_options(self) + + def accept(self, visitor:ParseTreeVisitor): + if hasattr( visitor, "visitFunc_options" ): + return visitor.visitFunc_options(self) + else: + return visitor.visitChildren(self) + + + + + def func_options(self): + + localctx = FuncTestCaseParser.Func_optionsContext(self, self._ctx, self.state) + self.enterRule(localctx, 88, self.RULE_func_options) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 386 + self.func_option() + self.state = 391 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==90: + self.state = 387 + self.match(FuncTestCaseParser.COMMA) + self.state = 388 + self.func_option() + self.state = 393 + self._errHandler.sync(self) + _la = self._input.LA(1) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/tests/coverage/antlr_parser/TestFileParser.tokens b/tests/coverage/antlr_parser/FuncTestCaseParser.tokens similarity index 69% rename from tests/coverage/antlr_parser/TestFileParser.tokens rename to tests/coverage/antlr_parser/FuncTestCaseParser.tokens index a3b65b74e..ccc9fabc8 100644 --- a/tests/coverage/antlr_parser/TestFileParser.tokens +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.tokens @@ -47,15 +47,15 @@ FP64=46 String=47 Binary=48 Timestamp=49 -TimestampTZ=50 +Timestamp_TZ=50 Date=51 Time=52 -IntervalYear=53 -IntervalDay=54 +Interval_Year=53 +Interval_Day=54 UUID=55 Decimal=56 -PrecisionTimestamp=57 -PrecisionTimestampTZ=58 +Precision_Timestamp=57 +Precision_Timestamp_TZ=58 FixedChar=59 VarChar=60 FixedBinary=61 @@ -65,33 +65,34 @@ List=64 Map=65 ANY=66 UserDefined=67 -Bool=68 -Str=69 -VBin=70 -Ts=71 -TsTZ=72 -IYear=73 -IDay=74 -Dec=75 -PTs=76 -PTsTZ=77 -FChar=78 -VChar=79 -FBin=80 -DOUBLE_COLON=81 -IDENTIFIER=82 -O_ANGLE_BRACKET=83 -C_ANGLE_BRACKET=84 -OPAREN=85 -CPAREN=86 -OBRACKET=87 -CBRACKET=88 -COMMA=89 -EQ=90 -COLON=91 -QMARK=92 -HASH=93 -DOT=94 +Geometry=68 +Bool=69 +Str=70 +VBin=71 +Ts=72 +TsTZ=73 +IYear=74 +IDay=75 +Dec=76 +PTs=77 +PTsTZ=78 +FChar=79 +VChar=80 +FBin=81 +DOUBLE_COLON=82 +IDENTIFIER=83 +O_ANGLE_BRACKET=84 +C_ANGLE_BRACKET=85 +OPAREN=86 +CPAREN=87 +OBRACKET=88 +CBRACKET=89 +COMMA=90 +EQ=91 +COLON=92 +QMARK=93 +HASH=94 +DOT=95 '### SUBSTRAIT_SCALAR_TEST:'=1 '### SUBSTRAIT_INCLUDE:'=3 ''=5 @@ -112,16 +113,16 @@ DOT=94 'S'=28 'F'=29 'null'=32 -'::'=81 -'<'=83 -'>'=84 -'('=85 -')'=86 -'['=87 -']'=88 -','=89 -'='=90 -':'=91 -'?'=92 -'#'=93 -'.'=94 +'::'=82 +'<'=84 +'>'=85 +'('=86 +')'=87 +'['=88 +']'=89 +','=90 +'='=91 +':'=92 +'?'=93 +'#'=94 +'.'=95 diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py new file mode 100644 index 000000000..496d161a1 --- /dev/null +++ b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py @@ -0,0 +1,561 @@ +# Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 +from antlr4 import * +if "." in __name__: + from .FuncTestCaseParser import FuncTestCaseParser +else: + from FuncTestCaseParser import FuncTestCaseParser + +# This class defines a complete listener for a parse tree produced by FuncTestCaseParser. +class FuncTestCaseParserListener(ParseTreeListener): + + # Enter a parse tree produced by FuncTestCaseParser#doc. + def enterDoc(self, ctx:FuncTestCaseParser.DocContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#doc. + def exitDoc(self, ctx:FuncTestCaseParser.DocContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#header. + def enterHeader(self, ctx:FuncTestCaseParser.HeaderContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#header. + def exitHeader(self, ctx:FuncTestCaseParser.HeaderContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#version. + def enterVersion(self, ctx:FuncTestCaseParser.VersionContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#version. + def exitVersion(self, ctx:FuncTestCaseParser.VersionContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#include. + def enterInclude(self, ctx:FuncTestCaseParser.IncludeContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#include. + def exitInclude(self, ctx:FuncTestCaseParser.IncludeContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#testGroupDescription. + def enterTestGroupDescription(self, ctx:FuncTestCaseParser.TestGroupDescriptionContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#testGroupDescription. + def exitTestGroupDescription(self, ctx:FuncTestCaseParser.TestGroupDescriptionContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#testCase. + def enterTestCase(self, ctx:FuncTestCaseParser.TestCaseContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#testCase. + def exitTestCase(self, ctx:FuncTestCaseParser.TestCaseContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#testGroup. + def enterTestGroup(self, ctx:FuncTestCaseParser.TestGroupContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#testGroup. + def exitTestGroup(self, ctx:FuncTestCaseParser.TestGroupContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#arguments. + def enterArguments(self, ctx:FuncTestCaseParser.ArgumentsContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#arguments. + def exitArguments(self, ctx:FuncTestCaseParser.ArgumentsContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#result. + def enterResult(self, ctx:FuncTestCaseParser.ResultContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#result. + def exitResult(self, ctx:FuncTestCaseParser.ResultContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#argument. + def enterArgument(self, ctx:FuncTestCaseParser.ArgumentContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#argument. + def exitArgument(self, ctx:FuncTestCaseParser.ArgumentContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#numericLiteral. + def enterNumericLiteral(self, ctx:FuncTestCaseParser.NumericLiteralContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#numericLiteral. + def exitNumericLiteral(self, ctx:FuncTestCaseParser.NumericLiteralContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#nullArg. + def enterNullArg(self, ctx:FuncTestCaseParser.NullArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#nullArg. + def exitNullArg(self, ctx:FuncTestCaseParser.NullArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i8Arg. + def enterI8Arg(self, ctx:FuncTestCaseParser.I8ArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i8Arg. + def exitI8Arg(self, ctx:FuncTestCaseParser.I8ArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i16Arg. + def enterI16Arg(self, ctx:FuncTestCaseParser.I16ArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i16Arg. + def exitI16Arg(self, ctx:FuncTestCaseParser.I16ArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i32Arg. + def enterI32Arg(self, ctx:FuncTestCaseParser.I32ArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i32Arg. + def exitI32Arg(self, ctx:FuncTestCaseParser.I32ArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i64Arg. + def enterI64Arg(self, ctx:FuncTestCaseParser.I64ArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i64Arg. + def exitI64Arg(self, ctx:FuncTestCaseParser.I64ArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#fp32Arg. + def enterFp32Arg(self, ctx:FuncTestCaseParser.Fp32ArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#fp32Arg. + def exitFp32Arg(self, ctx:FuncTestCaseParser.Fp32ArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#fp64Arg. + def enterFp64Arg(self, ctx:FuncTestCaseParser.Fp64ArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#fp64Arg. + def exitFp64Arg(self, ctx:FuncTestCaseParser.Fp64ArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#decimalArg. + def enterDecimalArg(self, ctx:FuncTestCaseParser.DecimalArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#decimalArg. + def exitDecimalArg(self, ctx:FuncTestCaseParser.DecimalArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#booleanArg. + def enterBooleanArg(self, ctx:FuncTestCaseParser.BooleanArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#booleanArg. + def exitBooleanArg(self, ctx:FuncTestCaseParser.BooleanArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#stringArg. + def enterStringArg(self, ctx:FuncTestCaseParser.StringArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#stringArg. + def exitStringArg(self, ctx:FuncTestCaseParser.StringArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#dateArg. + def enterDateArg(self, ctx:FuncTestCaseParser.DateArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#dateArg. + def exitDateArg(self, ctx:FuncTestCaseParser.DateArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#timeArg. + def enterTimeArg(self, ctx:FuncTestCaseParser.TimeArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#timeArg. + def exitTimeArg(self, ctx:FuncTestCaseParser.TimeArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#timestampArg. + def enterTimestampArg(self, ctx:FuncTestCaseParser.TimestampArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#timestampArg. + def exitTimestampArg(self, ctx:FuncTestCaseParser.TimestampArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#timestampTzArg. + def enterTimestampTzArg(self, ctx:FuncTestCaseParser.TimestampTzArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#timestampTzArg. + def exitTimestampTzArg(self, ctx:FuncTestCaseParser.TimestampTzArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#intervalYearArg. + def enterIntervalYearArg(self, ctx:FuncTestCaseParser.IntervalYearArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#intervalYearArg. + def exitIntervalYearArg(self, ctx:FuncTestCaseParser.IntervalYearArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#intervalDayArg. + def enterIntervalDayArg(self, ctx:FuncTestCaseParser.IntervalDayArgContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#intervalDayArg. + def exitIntervalDayArg(self, ctx:FuncTestCaseParser.IntervalDayArgContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#intervalYearLiteral. + def enterIntervalYearLiteral(self, ctx:FuncTestCaseParser.IntervalYearLiteralContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#intervalYearLiteral. + def exitIntervalYearLiteral(self, ctx:FuncTestCaseParser.IntervalYearLiteralContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#intervalDayLiteral. + def enterIntervalDayLiteral(self, ctx:FuncTestCaseParser.IntervalDayLiteralContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#intervalDayLiteral. + def exitIntervalDayLiteral(self, ctx:FuncTestCaseParser.IntervalDayLiteralContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#timeInterval. + def enterTimeInterval(self, ctx:FuncTestCaseParser.TimeIntervalContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#timeInterval. + def exitTimeInterval(self, ctx:FuncTestCaseParser.TimeIntervalContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#datatype. + def enterDatatype(self, ctx:FuncTestCaseParser.DatatypeContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#datatype. + def exitDatatype(self, ctx:FuncTestCaseParser.DatatypeContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#Boolean. + def enterBoolean(self, ctx:FuncTestCaseParser.BooleanContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#Boolean. + def exitBoolean(self, ctx:FuncTestCaseParser.BooleanContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i8. + def enterI8(self, ctx:FuncTestCaseParser.I8Context): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i8. + def exitI8(self, ctx:FuncTestCaseParser.I8Context): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i16. + def enterI16(self, ctx:FuncTestCaseParser.I16Context): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i16. + def exitI16(self, ctx:FuncTestCaseParser.I16Context): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i32. + def enterI32(self, ctx:FuncTestCaseParser.I32Context): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i32. + def exitI32(self, ctx:FuncTestCaseParser.I32Context): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#i64. + def enterI64(self, ctx:FuncTestCaseParser.I64Context): + pass + + # Exit a parse tree produced by FuncTestCaseParser#i64. + def exitI64(self, ctx:FuncTestCaseParser.I64Context): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#fp32. + def enterFp32(self, ctx:FuncTestCaseParser.Fp32Context): + pass + + # Exit a parse tree produced by FuncTestCaseParser#fp32. + def exitFp32(self, ctx:FuncTestCaseParser.Fp32Context): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#fp64. + def enterFp64(self, ctx:FuncTestCaseParser.Fp64Context): + pass + + # Exit a parse tree produced by FuncTestCaseParser#fp64. + def exitFp64(self, ctx:FuncTestCaseParser.Fp64Context): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#string. + def enterString(self, ctx:FuncTestCaseParser.StringContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#string. + def exitString(self, ctx:FuncTestCaseParser.StringContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#binary. + def enterBinary(self, ctx:FuncTestCaseParser.BinaryContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#binary. + def exitBinary(self, ctx:FuncTestCaseParser.BinaryContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#timestamp. + def enterTimestamp(self, ctx:FuncTestCaseParser.TimestampContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#timestamp. + def exitTimestamp(self, ctx:FuncTestCaseParser.TimestampContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#timestampTz. + def enterTimestampTz(self, ctx:FuncTestCaseParser.TimestampTzContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#timestampTz. + def exitTimestampTz(self, ctx:FuncTestCaseParser.TimestampTzContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#date. + def enterDate(self, ctx:FuncTestCaseParser.DateContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#date. + def exitDate(self, ctx:FuncTestCaseParser.DateContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#time. + def enterTime(self, ctx:FuncTestCaseParser.TimeContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#time. + def exitTime(self, ctx:FuncTestCaseParser.TimeContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#intervalDay. + def enterIntervalDay(self, ctx:FuncTestCaseParser.IntervalDayContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#intervalDay. + def exitIntervalDay(self, ctx:FuncTestCaseParser.IntervalDayContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#intervalYear. + def enterIntervalYear(self, ctx:FuncTestCaseParser.IntervalYearContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#intervalYear. + def exitIntervalYear(self, ctx:FuncTestCaseParser.IntervalYearContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#uuid. + def enterUuid(self, ctx:FuncTestCaseParser.UuidContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#uuid. + def exitUuid(self, ctx:FuncTestCaseParser.UuidContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#userDefined. + def enterUserDefined(self, ctx:FuncTestCaseParser.UserDefinedContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#userDefined. + def exitUserDefined(self, ctx:FuncTestCaseParser.UserDefinedContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#fixedChar. + def enterFixedChar(self, ctx:FuncTestCaseParser.FixedCharContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#fixedChar. + def exitFixedChar(self, ctx:FuncTestCaseParser.FixedCharContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#varChar. + def enterVarChar(self, ctx:FuncTestCaseParser.VarCharContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#varChar. + def exitVarChar(self, ctx:FuncTestCaseParser.VarCharContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#fixedBinary. + def enterFixedBinary(self, ctx:FuncTestCaseParser.FixedBinaryContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#fixedBinary. + def exitFixedBinary(self, ctx:FuncTestCaseParser.FixedBinaryContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#decimal. + def enterDecimal(self, ctx:FuncTestCaseParser.DecimalContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#decimal. + def exitDecimal(self, ctx:FuncTestCaseParser.DecimalContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#precisionTimestamp. + def enterPrecisionTimestamp(self, ctx:FuncTestCaseParser.PrecisionTimestampContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#precisionTimestamp. + def exitPrecisionTimestamp(self, ctx:FuncTestCaseParser.PrecisionTimestampContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#precisionTimestampTZ. + def enterPrecisionTimestampTZ(self, ctx:FuncTestCaseParser.PrecisionTimestampTZContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#precisionTimestampTZ. + def exitPrecisionTimestampTZ(self, ctx:FuncTestCaseParser.PrecisionTimestampTZContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#parameterizedType. + def enterParameterizedType(self, ctx:FuncTestCaseParser.ParameterizedTypeContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#parameterizedType. + def exitParameterizedType(self, ctx:FuncTestCaseParser.ParameterizedTypeContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#integerLiteral. + def enterIntegerLiteral(self, ctx:FuncTestCaseParser.IntegerLiteralContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#integerLiteral. + def exitIntegerLiteral(self, ctx:FuncTestCaseParser.IntegerLiteralContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#substraitError. + def enterSubstraitError(self, ctx:FuncTestCaseParser.SubstraitErrorContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#substraitError. + def exitSubstraitError(self, ctx:FuncTestCaseParser.SubstraitErrorContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#func_option. + def enterFunc_option(self, ctx:FuncTestCaseParser.Func_optionContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#func_option. + def exitFunc_option(self, ctx:FuncTestCaseParser.Func_optionContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#option_name. + def enterOption_name(self, ctx:FuncTestCaseParser.Option_nameContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#option_name. + def exitOption_name(self, ctx:FuncTestCaseParser.Option_nameContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#option_value. + def enterOption_value(self, ctx:FuncTestCaseParser.Option_valueContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#option_value. + def exitOption_value(self, ctx:FuncTestCaseParser.Option_valueContext): + pass + + + # Enter a parse tree produced by FuncTestCaseParser#func_options. + def enterFunc_options(self, ctx:FuncTestCaseParser.Func_optionsContext): + pass + + # Exit a parse tree produced by FuncTestCaseParser#func_options. + def exitFunc_options(self, ctx:FuncTestCaseParser.Func_optionsContext): + pass + + + +del FuncTestCaseParser \ No newline at end of file diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py new file mode 100644 index 000000000..d27e03d66 --- /dev/null +++ b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py @@ -0,0 +1,318 @@ +# Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 +from antlr4 import * +if "." in __name__: + from .FuncTestCaseParser import FuncTestCaseParser +else: + from FuncTestCaseParser import FuncTestCaseParser + +# This class defines a complete generic visitor for a parse tree produced by FuncTestCaseParser. + +class FuncTestCaseParserVisitor(ParseTreeVisitor): + + # Visit a parse tree produced by FuncTestCaseParser#doc. + def visitDoc(self, ctx:FuncTestCaseParser.DocContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#header. + def visitHeader(self, ctx:FuncTestCaseParser.HeaderContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#version. + def visitVersion(self, ctx:FuncTestCaseParser.VersionContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#include. + def visitInclude(self, ctx:FuncTestCaseParser.IncludeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#testGroupDescription. + def visitTestGroupDescription(self, ctx:FuncTestCaseParser.TestGroupDescriptionContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#testCase. + def visitTestCase(self, ctx:FuncTestCaseParser.TestCaseContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#testGroup. + def visitTestGroup(self, ctx:FuncTestCaseParser.TestGroupContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#arguments. + def visitArguments(self, ctx:FuncTestCaseParser.ArgumentsContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#result. + def visitResult(self, ctx:FuncTestCaseParser.ResultContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#argument. + def visitArgument(self, ctx:FuncTestCaseParser.ArgumentContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#numericLiteral. + def visitNumericLiteral(self, ctx:FuncTestCaseParser.NumericLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#nullArg. + def visitNullArg(self, ctx:FuncTestCaseParser.NullArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i8Arg. + def visitI8Arg(self, ctx:FuncTestCaseParser.I8ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i16Arg. + def visitI16Arg(self, ctx:FuncTestCaseParser.I16ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i32Arg. + def visitI32Arg(self, ctx:FuncTestCaseParser.I32ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i64Arg. + def visitI64Arg(self, ctx:FuncTestCaseParser.I64ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#fp32Arg. + def visitFp32Arg(self, ctx:FuncTestCaseParser.Fp32ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#fp64Arg. + def visitFp64Arg(self, ctx:FuncTestCaseParser.Fp64ArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#decimalArg. + def visitDecimalArg(self, ctx:FuncTestCaseParser.DecimalArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#booleanArg. + def visitBooleanArg(self, ctx:FuncTestCaseParser.BooleanArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#stringArg. + def visitStringArg(self, ctx:FuncTestCaseParser.StringArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#dateArg. + def visitDateArg(self, ctx:FuncTestCaseParser.DateArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#timeArg. + def visitTimeArg(self, ctx:FuncTestCaseParser.TimeArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#timestampArg. + def visitTimestampArg(self, ctx:FuncTestCaseParser.TimestampArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#timestampTzArg. + def visitTimestampTzArg(self, ctx:FuncTestCaseParser.TimestampTzArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#intervalYearArg. + def visitIntervalYearArg(self, ctx:FuncTestCaseParser.IntervalYearArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#intervalDayArg. + def visitIntervalDayArg(self, ctx:FuncTestCaseParser.IntervalDayArgContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#intervalYearLiteral. + def visitIntervalYearLiteral(self, ctx:FuncTestCaseParser.IntervalYearLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#intervalDayLiteral. + def visitIntervalDayLiteral(self, ctx:FuncTestCaseParser.IntervalDayLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#timeInterval. + def visitTimeInterval(self, ctx:FuncTestCaseParser.TimeIntervalContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#datatype. + def visitDatatype(self, ctx:FuncTestCaseParser.DatatypeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#Boolean. + def visitBoolean(self, ctx:FuncTestCaseParser.BooleanContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i8. + def visitI8(self, ctx:FuncTestCaseParser.I8Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i16. + def visitI16(self, ctx:FuncTestCaseParser.I16Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i32. + def visitI32(self, ctx:FuncTestCaseParser.I32Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#i64. + def visitI64(self, ctx:FuncTestCaseParser.I64Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#fp32. + def visitFp32(self, ctx:FuncTestCaseParser.Fp32Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#fp64. + def visitFp64(self, ctx:FuncTestCaseParser.Fp64Context): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#string. + def visitString(self, ctx:FuncTestCaseParser.StringContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#binary. + def visitBinary(self, ctx:FuncTestCaseParser.BinaryContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#timestamp. + def visitTimestamp(self, ctx:FuncTestCaseParser.TimestampContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#timestampTz. + def visitTimestampTz(self, ctx:FuncTestCaseParser.TimestampTzContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#date. + def visitDate(self, ctx:FuncTestCaseParser.DateContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#time. + def visitTime(self, ctx:FuncTestCaseParser.TimeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#intervalDay. + def visitIntervalDay(self, ctx:FuncTestCaseParser.IntervalDayContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#intervalYear. + def visitIntervalYear(self, ctx:FuncTestCaseParser.IntervalYearContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#uuid. + def visitUuid(self, ctx:FuncTestCaseParser.UuidContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#userDefined. + def visitUserDefined(self, ctx:FuncTestCaseParser.UserDefinedContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#fixedChar. + def visitFixedChar(self, ctx:FuncTestCaseParser.FixedCharContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#varChar. + def visitVarChar(self, ctx:FuncTestCaseParser.VarCharContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#fixedBinary. + def visitFixedBinary(self, ctx:FuncTestCaseParser.FixedBinaryContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#decimal. + def visitDecimal(self, ctx:FuncTestCaseParser.DecimalContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#precisionTimestamp. + def visitPrecisionTimestamp(self, ctx:FuncTestCaseParser.PrecisionTimestampContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#precisionTimestampTZ. + def visitPrecisionTimestampTZ(self, ctx:FuncTestCaseParser.PrecisionTimestampTZContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#parameterizedType. + def visitParameterizedType(self, ctx:FuncTestCaseParser.ParameterizedTypeContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#integerLiteral. + def visitIntegerLiteral(self, ctx:FuncTestCaseParser.IntegerLiteralContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#substraitError. + def visitSubstraitError(self, ctx:FuncTestCaseParser.SubstraitErrorContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#func_option. + def visitFunc_option(self, ctx:FuncTestCaseParser.Func_optionContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#option_name. + def visitOption_name(self, ctx:FuncTestCaseParser.Option_nameContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#option_value. + def visitOption_value(self, ctx:FuncTestCaseParser.Option_valueContext): + return self.visitChildren(ctx) + + + # Visit a parse tree produced by FuncTestCaseParser#func_options. + def visitFunc_options(self, ctx:FuncTestCaseParser.Func_optionsContext): + return self.visitChildren(ctx) + + + +del FuncTestCaseParser \ No newline at end of file diff --git a/tests/coverage/antlr_parser/SubstraitLexer.interp b/tests/coverage/antlr_parser/SubstraitLexer.interp index b34496d1a..cb67ea7cf 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.interp +++ b/tests/coverage/antlr_parser/SubstraitLexer.interp @@ -47,6 +47,7 @@ null null null null +null '::' null '<' @@ -80,15 +81,15 @@ FP64 String Binary Timestamp -TimestampTZ +Timestamp_TZ Date Time -IntervalYear -IntervalDay +Interval_Year +Interval_Day UUID Decimal -PrecisionTimestamp -PrecisionTimestampTZ +Precision_Timestamp +Precision_Timestamp_TZ FixedChar VarChar FixedBinary @@ -98,6 +99,7 @@ List Map ANY UserDefined +Geometry Bool Str VBin @@ -171,15 +173,15 @@ FP64 String Binary Timestamp -TimestampTZ +Timestamp_TZ Date Time -IntervalYear -IntervalDay +Interval_Year +Interval_Day UUID Decimal -PrecisionTimestamp -PrecisionTimestampTZ +Precision_Timestamp +Precision_Timestamp_TZ FixedChar VarChar FixedBinary @@ -189,6 +191,7 @@ List Map ANY UserDefined +Geometry Bool Str VBin @@ -225,4 +228,4 @@ mode names: DEFAULT_MODE atn: -[4, 0, 61, 619, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 184, 8, 0, 10, 0, 12, 0, 187, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 196, 8, 1, 11, 1, 12, 1, 197, 1, 1, 3, 1, 201, 8, 1, 1, 1, 5, 1, 204, 8, 1, 10, 1, 12, 1, 207, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 2, 215, 8, 2, 11, 2, 12, 2, 216, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 5, 30, 278, 8, 30, 10, 30, 12, 30, 281, 9, 30, 3, 30, 283, 8, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 5, 76, 591, 8, 76, 10, 76, 12, 76, 594, 9, 76, 1, 77, 1, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, 1, 88, 0, 0, 89, 1, 1, 3, 2, 5, 3, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0, 17, 0, 19, 0, 21, 0, 23, 0, 25, 0, 27, 0, 29, 0, 31, 0, 33, 0, 35, 0, 37, 0, 39, 0, 41, 0, 43, 0, 45, 0, 47, 0, 49, 0, 51, 0, 53, 0, 55, 0, 57, 0, 59, 0, 61, 0, 63, 4, 65, 5, 67, 6, 69, 7, 71, 8, 73, 9, 75, 10, 77, 11, 79, 12, 81, 13, 83, 14, 85, 15, 87, 16, 89, 17, 91, 18, 93, 19, 95, 20, 97, 21, 99, 22, 101, 23, 103, 24, 105, 25, 107, 26, 109, 27, 111, 28, 113, 29, 115, 30, 117, 31, 119, 32, 121, 33, 123, 34, 125, 35, 127, 36, 129, 37, 131, 38, 133, 39, 135, 40, 137, 41, 139, 42, 141, 43, 143, 44, 145, 45, 147, 46, 149, 47, 151, 48, 153, 49, 155, 50, 157, 51, 159, 52, 161, 53, 163, 54, 165, 55, 167, 56, 169, 57, 171, 58, 173, 59, 175, 60, 177, 61, 1, 0, 34, 2, 0, 10, 10, 13, 13, 1, 0, 42, 42, 2, 0, 42, 42, 47, 47, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 69, 69, 101, 101, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 1, 0, 48, 57, 1, 0, 49, 57, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 598, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 1, 179, 1, 0, 0, 0, 3, 190, 1, 0, 0, 0, 5, 214, 1, 0, 0, 0, 7, 220, 1, 0, 0, 0, 9, 222, 1, 0, 0, 0, 11, 224, 1, 0, 0, 0, 13, 226, 1, 0, 0, 0, 15, 228, 1, 0, 0, 0, 17, 230, 1, 0, 0, 0, 19, 232, 1, 0, 0, 0, 21, 234, 1, 0, 0, 0, 23, 236, 1, 0, 0, 0, 25, 238, 1, 0, 0, 0, 27, 240, 1, 0, 0, 0, 29, 242, 1, 0, 0, 0, 31, 244, 1, 0, 0, 0, 33, 246, 1, 0, 0, 0, 35, 248, 1, 0, 0, 0, 37, 250, 1, 0, 0, 0, 39, 252, 1, 0, 0, 0, 41, 254, 1, 0, 0, 0, 43, 256, 1, 0, 0, 0, 45, 258, 1, 0, 0, 0, 47, 260, 1, 0, 0, 0, 49, 262, 1, 0, 0, 0, 51, 264, 1, 0, 0, 0, 53, 266, 1, 0, 0, 0, 55, 268, 1, 0, 0, 0, 57, 270, 1, 0, 0, 0, 59, 272, 1, 0, 0, 0, 61, 282, 1, 0, 0, 0, 63, 284, 1, 0, 0, 0, 65, 287, 1, 0, 0, 0, 67, 292, 1, 0, 0, 0, 69, 297, 1, 0, 0, 0, 71, 305, 1, 0, 0, 0, 73, 308, 1, 0, 0, 0, 75, 312, 1, 0, 0, 0, 77, 316, 1, 0, 0, 0, 79, 320, 1, 0, 0, 0, 81, 325, 1, 0, 0, 0, 83, 330, 1, 0, 0, 0, 85, 337, 1, 0, 0, 0, 87, 344, 1, 0, 0, 0, 89, 354, 1, 0, 0, 0, 91, 367, 1, 0, 0, 0, 93, 372, 1, 0, 0, 0, 95, 377, 1, 0, 0, 0, 97, 391, 1, 0, 0, 0, 99, 404, 1, 0, 0, 0, 101, 409, 1, 0, 0, 0, 103, 417, 1, 0, 0, 0, 105, 437, 1, 0, 0, 0, 107, 460, 1, 0, 0, 0, 109, 470, 1, 0, 0, 0, 111, 478, 1, 0, 0, 0, 113, 490, 1, 0, 0, 0, 115, 497, 1, 0, 0, 0, 117, 505, 1, 0, 0, 0, 119, 510, 1, 0, 0, 0, 121, 514, 1, 0, 0, 0, 123, 518, 1, 0, 0, 0, 125, 521, 1, 0, 0, 0, 127, 526, 1, 0, 0, 0, 129, 530, 1, 0, 0, 0, 131, 535, 1, 0, 0, 0, 133, 538, 1, 0, 0, 0, 135, 543, 1, 0, 0, 0, 137, 549, 1, 0, 0, 0, 139, 554, 1, 0, 0, 0, 141, 558, 1, 0, 0, 0, 143, 562, 1, 0, 0, 0, 145, 568, 1, 0, 0, 0, 147, 574, 1, 0, 0, 0, 149, 580, 1, 0, 0, 0, 151, 585, 1, 0, 0, 0, 153, 588, 1, 0, 0, 0, 155, 595, 1, 0, 0, 0, 157, 597, 1, 0, 0, 0, 159, 599, 1, 0, 0, 0, 161, 601, 1, 0, 0, 0, 163, 603, 1, 0, 0, 0, 165, 605, 1, 0, 0, 0, 167, 607, 1, 0, 0, 0, 169, 609, 1, 0, 0, 0, 171, 611, 1, 0, 0, 0, 173, 613, 1, 0, 0, 0, 175, 615, 1, 0, 0, 0, 177, 617, 1, 0, 0, 0, 179, 180, 5, 47, 0, 0, 180, 181, 5, 47, 0, 0, 181, 185, 1, 0, 0, 0, 182, 184, 8, 0, 0, 0, 183, 182, 1, 0, 0, 0, 184, 187, 1, 0, 0, 0, 185, 183, 1, 0, 0, 0, 185, 186, 1, 0, 0, 0, 186, 188, 1, 0, 0, 0, 187, 185, 1, 0, 0, 0, 188, 189, 6, 0, 0, 0, 189, 2, 1, 0, 0, 0, 190, 191, 5, 47, 0, 0, 191, 192, 5, 42, 0, 0, 192, 200, 1, 0, 0, 0, 193, 201, 8, 1, 0, 0, 194, 196, 5, 42, 0, 0, 195, 194, 1, 0, 0, 0, 196, 197, 1, 0, 0, 0, 197, 195, 1, 0, 0, 0, 197, 198, 1, 0, 0, 0, 198, 199, 1, 0, 0, 0, 199, 201, 8, 2, 0, 0, 200, 193, 1, 0, 0, 0, 200, 195, 1, 0, 0, 0, 201, 205, 1, 0, 0, 0, 202, 204, 5, 42, 0, 0, 203, 202, 1, 0, 0, 0, 204, 207, 1, 0, 0, 0, 205, 203, 1, 0, 0, 0, 205, 206, 1, 0, 0, 0, 206, 208, 1, 0, 0, 0, 207, 205, 1, 0, 0, 0, 208, 209, 5, 42, 0, 0, 209, 210, 5, 47, 0, 0, 210, 211, 1, 0, 0, 0, 211, 212, 6, 1, 0, 0, 212, 4, 1, 0, 0, 0, 213, 215, 7, 3, 0, 0, 214, 213, 1, 0, 0, 0, 215, 216, 1, 0, 0, 0, 216, 214, 1, 0, 0, 0, 216, 217, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 219, 6, 2, 0, 0, 219, 6, 1, 0, 0, 0, 220, 221, 7, 4, 0, 0, 221, 8, 1, 0, 0, 0, 222, 223, 7, 5, 0, 0, 223, 10, 1, 0, 0, 0, 224, 225, 7, 6, 0, 0, 225, 12, 1, 0, 0, 0, 226, 227, 7, 7, 0, 0, 227, 14, 1, 0, 0, 0, 228, 229, 7, 8, 0, 0, 229, 16, 1, 0, 0, 0, 230, 231, 7, 9, 0, 0, 231, 18, 1, 0, 0, 0, 232, 233, 7, 10, 0, 0, 233, 20, 1, 0, 0, 0, 234, 235, 7, 11, 0, 0, 235, 22, 1, 0, 0, 0, 236, 237, 7, 12, 0, 0, 237, 24, 1, 0, 0, 0, 238, 239, 7, 13, 0, 0, 239, 26, 1, 0, 0, 0, 240, 241, 7, 14, 0, 0, 241, 28, 1, 0, 0, 0, 242, 243, 7, 15, 0, 0, 243, 30, 1, 0, 0, 0, 244, 245, 7, 16, 0, 0, 245, 32, 1, 0, 0, 0, 246, 247, 7, 17, 0, 0, 247, 34, 1, 0, 0, 0, 248, 249, 7, 18, 0, 0, 249, 36, 1, 0, 0, 0, 250, 251, 7, 19, 0, 0, 251, 38, 1, 0, 0, 0, 252, 253, 7, 20, 0, 0, 253, 40, 1, 0, 0, 0, 254, 255, 7, 21, 0, 0, 255, 42, 1, 0, 0, 0, 256, 257, 7, 22, 0, 0, 257, 44, 1, 0, 0, 0, 258, 259, 7, 23, 0, 0, 259, 46, 1, 0, 0, 0, 260, 261, 7, 24, 0, 0, 261, 48, 1, 0, 0, 0, 262, 263, 7, 25, 0, 0, 263, 50, 1, 0, 0, 0, 264, 265, 7, 26, 0, 0, 265, 52, 1, 0, 0, 0, 266, 267, 7, 27, 0, 0, 267, 54, 1, 0, 0, 0, 268, 269, 7, 28, 0, 0, 269, 56, 1, 0, 0, 0, 270, 271, 7, 29, 0, 0, 271, 58, 1, 0, 0, 0, 272, 273, 7, 30, 0, 0, 273, 60, 1, 0, 0, 0, 274, 283, 5, 48, 0, 0, 275, 279, 7, 31, 0, 0, 276, 278, 7, 30, 0, 0, 277, 276, 1, 0, 0, 0, 278, 281, 1, 0, 0, 0, 279, 277, 1, 0, 0, 0, 279, 280, 1, 0, 0, 0, 280, 283, 1, 0, 0, 0, 281, 279, 1, 0, 0, 0, 282, 274, 1, 0, 0, 0, 282, 275, 1, 0, 0, 0, 283, 62, 1, 0, 0, 0, 284, 285, 3, 23, 11, 0, 285, 286, 3, 17, 8, 0, 286, 64, 1, 0, 0, 0, 287, 288, 3, 45, 22, 0, 288, 289, 3, 21, 10, 0, 289, 290, 3, 15, 7, 0, 290, 291, 3, 33, 16, 0, 291, 66, 1, 0, 0, 0, 292, 293, 3, 15, 7, 0, 293, 294, 3, 29, 14, 0, 294, 295, 3, 43, 21, 0, 295, 296, 3, 15, 7, 0, 296, 68, 1, 0, 0, 0, 297, 298, 3, 9, 4, 0, 298, 299, 3, 35, 17, 0, 299, 300, 3, 35, 17, 0, 300, 301, 3, 29, 14, 0, 301, 302, 3, 15, 7, 0, 302, 303, 3, 7, 3, 0, 303, 304, 3, 33, 16, 0, 304, 70, 1, 0, 0, 0, 305, 306, 3, 23, 11, 0, 306, 307, 5, 56, 0, 0, 307, 72, 1, 0, 0, 0, 308, 309, 3, 23, 11, 0, 309, 310, 5, 49, 0, 0, 310, 311, 5, 54, 0, 0, 311, 74, 1, 0, 0, 0, 312, 313, 3, 23, 11, 0, 313, 314, 5, 51, 0, 0, 314, 315, 5, 50, 0, 0, 315, 76, 1, 0, 0, 0, 316, 317, 3, 23, 11, 0, 317, 318, 5, 54, 0, 0, 318, 319, 5, 52, 0, 0, 319, 78, 1, 0, 0, 0, 320, 321, 3, 17, 8, 0, 321, 322, 3, 37, 18, 0, 322, 323, 5, 51, 0, 0, 323, 324, 5, 50, 0, 0, 324, 80, 1, 0, 0, 0, 325, 326, 3, 17, 8, 0, 326, 327, 3, 37, 18, 0, 327, 328, 5, 54, 0, 0, 328, 329, 5, 52, 0, 0, 329, 82, 1, 0, 0, 0, 330, 331, 3, 43, 21, 0, 331, 332, 3, 45, 22, 0, 332, 333, 3, 41, 20, 0, 333, 334, 3, 23, 11, 0, 334, 335, 3, 33, 16, 0, 335, 336, 3, 19, 9, 0, 336, 84, 1, 0, 0, 0, 337, 338, 3, 9, 4, 0, 338, 339, 3, 23, 11, 0, 339, 340, 3, 33, 16, 0, 340, 341, 3, 7, 3, 0, 341, 342, 3, 41, 20, 0, 342, 343, 3, 55, 27, 0, 343, 86, 1, 0, 0, 0, 344, 345, 3, 45, 22, 0, 345, 346, 3, 23, 11, 0, 346, 347, 3, 31, 15, 0, 347, 348, 3, 15, 7, 0, 348, 349, 3, 43, 21, 0, 349, 350, 3, 45, 22, 0, 350, 351, 3, 7, 3, 0, 351, 352, 3, 31, 15, 0, 352, 353, 3, 37, 18, 0, 353, 88, 1, 0, 0, 0, 354, 355, 3, 45, 22, 0, 355, 356, 3, 23, 11, 0, 356, 357, 3, 31, 15, 0, 357, 358, 3, 15, 7, 0, 358, 359, 3, 43, 21, 0, 359, 360, 3, 45, 22, 0, 360, 361, 3, 7, 3, 0, 361, 362, 3, 31, 15, 0, 362, 363, 3, 37, 18, 0, 363, 364, 5, 95, 0, 0, 364, 365, 3, 45, 22, 0, 365, 366, 3, 57, 28, 0, 366, 90, 1, 0, 0, 0, 367, 368, 3, 13, 6, 0, 368, 369, 3, 7, 3, 0, 369, 370, 3, 45, 22, 0, 370, 371, 3, 15, 7, 0, 371, 92, 1, 0, 0, 0, 372, 373, 3, 45, 22, 0, 373, 374, 3, 23, 11, 0, 374, 375, 3, 31, 15, 0, 375, 376, 3, 15, 7, 0, 376, 94, 1, 0, 0, 0, 377, 378, 3, 23, 11, 0, 378, 379, 3, 33, 16, 0, 379, 380, 3, 45, 22, 0, 380, 381, 3, 15, 7, 0, 381, 382, 3, 41, 20, 0, 382, 383, 3, 49, 24, 0, 383, 384, 3, 7, 3, 0, 384, 385, 3, 29, 14, 0, 385, 386, 5, 95, 0, 0, 386, 387, 3, 55, 27, 0, 387, 388, 3, 15, 7, 0, 388, 389, 3, 7, 3, 0, 389, 390, 3, 41, 20, 0, 390, 96, 1, 0, 0, 0, 391, 392, 3, 23, 11, 0, 392, 393, 3, 33, 16, 0, 393, 394, 3, 45, 22, 0, 394, 395, 3, 15, 7, 0, 395, 396, 3, 41, 20, 0, 396, 397, 3, 49, 24, 0, 397, 398, 3, 7, 3, 0, 398, 399, 3, 29, 14, 0, 399, 400, 5, 95, 0, 0, 400, 401, 3, 13, 6, 0, 401, 402, 3, 7, 3, 0, 402, 403, 3, 55, 27, 0, 403, 98, 1, 0, 0, 0, 404, 405, 3, 47, 23, 0, 405, 406, 3, 47, 23, 0, 406, 407, 3, 23, 11, 0, 407, 408, 3, 13, 6, 0, 408, 100, 1, 0, 0, 0, 409, 410, 3, 13, 6, 0, 410, 411, 3, 15, 7, 0, 411, 412, 3, 11, 5, 0, 412, 413, 3, 23, 11, 0, 413, 414, 3, 31, 15, 0, 414, 415, 3, 7, 3, 0, 415, 416, 3, 29, 14, 0, 416, 102, 1, 0, 0, 0, 417, 418, 3, 37, 18, 0, 418, 419, 3, 41, 20, 0, 419, 420, 3, 15, 7, 0, 420, 421, 3, 11, 5, 0, 421, 422, 3, 23, 11, 0, 422, 423, 3, 43, 21, 0, 423, 424, 3, 23, 11, 0, 424, 425, 3, 35, 17, 0, 425, 426, 3, 33, 16, 0, 426, 427, 5, 95, 0, 0, 427, 428, 3, 45, 22, 0, 428, 429, 3, 23, 11, 0, 429, 430, 3, 31, 15, 0, 430, 431, 3, 15, 7, 0, 431, 432, 3, 43, 21, 0, 432, 433, 3, 45, 22, 0, 433, 434, 3, 7, 3, 0, 434, 435, 3, 31, 15, 0, 435, 436, 3, 37, 18, 0, 436, 104, 1, 0, 0, 0, 437, 438, 3, 37, 18, 0, 438, 439, 3, 41, 20, 0, 439, 440, 3, 15, 7, 0, 440, 441, 3, 11, 5, 0, 441, 442, 3, 23, 11, 0, 442, 443, 3, 43, 21, 0, 443, 444, 3, 23, 11, 0, 444, 445, 3, 35, 17, 0, 445, 446, 3, 33, 16, 0, 446, 447, 5, 95, 0, 0, 447, 448, 3, 45, 22, 0, 448, 449, 3, 23, 11, 0, 449, 450, 3, 31, 15, 0, 450, 451, 3, 15, 7, 0, 451, 452, 3, 43, 21, 0, 452, 453, 3, 45, 22, 0, 453, 454, 3, 7, 3, 0, 454, 455, 3, 31, 15, 0, 455, 456, 3, 37, 18, 0, 456, 457, 5, 95, 0, 0, 457, 458, 3, 45, 22, 0, 458, 459, 3, 57, 28, 0, 459, 106, 1, 0, 0, 0, 460, 461, 3, 17, 8, 0, 461, 462, 3, 23, 11, 0, 462, 463, 3, 53, 26, 0, 463, 464, 3, 15, 7, 0, 464, 465, 3, 13, 6, 0, 465, 466, 3, 11, 5, 0, 466, 467, 3, 21, 10, 0, 467, 468, 3, 7, 3, 0, 468, 469, 3, 41, 20, 0, 469, 108, 1, 0, 0, 0, 470, 471, 3, 49, 24, 0, 471, 472, 3, 7, 3, 0, 472, 473, 3, 41, 20, 0, 473, 474, 3, 11, 5, 0, 474, 475, 3, 21, 10, 0, 475, 476, 3, 7, 3, 0, 476, 477, 3, 41, 20, 0, 477, 110, 1, 0, 0, 0, 478, 479, 3, 17, 8, 0, 479, 480, 3, 23, 11, 0, 480, 481, 3, 53, 26, 0, 481, 482, 3, 15, 7, 0, 482, 483, 3, 13, 6, 0, 483, 484, 3, 9, 4, 0, 484, 485, 3, 23, 11, 0, 485, 486, 3, 33, 16, 0, 486, 487, 3, 7, 3, 0, 487, 488, 3, 41, 20, 0, 488, 489, 3, 55, 27, 0, 489, 112, 1, 0, 0, 0, 490, 491, 3, 43, 21, 0, 491, 492, 3, 45, 22, 0, 492, 493, 3, 41, 20, 0, 493, 494, 3, 47, 23, 0, 494, 495, 3, 11, 5, 0, 495, 496, 3, 45, 22, 0, 496, 114, 1, 0, 0, 0, 497, 498, 3, 33, 16, 0, 498, 499, 3, 43, 21, 0, 499, 500, 3, 45, 22, 0, 500, 501, 3, 41, 20, 0, 501, 502, 3, 47, 23, 0, 502, 503, 3, 11, 5, 0, 503, 504, 3, 45, 22, 0, 504, 116, 1, 0, 0, 0, 505, 506, 3, 29, 14, 0, 506, 507, 3, 23, 11, 0, 507, 508, 3, 43, 21, 0, 508, 509, 3, 45, 22, 0, 509, 118, 1, 0, 0, 0, 510, 511, 3, 31, 15, 0, 511, 512, 3, 7, 3, 0, 512, 513, 3, 37, 18, 0, 513, 120, 1, 0, 0, 0, 514, 515, 3, 7, 3, 0, 515, 516, 3, 33, 16, 0, 516, 517, 3, 55, 27, 0, 517, 122, 1, 0, 0, 0, 518, 519, 3, 47, 23, 0, 519, 520, 5, 33, 0, 0, 520, 124, 1, 0, 0, 0, 521, 522, 3, 9, 4, 0, 522, 523, 3, 35, 17, 0, 523, 524, 3, 35, 17, 0, 524, 525, 3, 29, 14, 0, 525, 126, 1, 0, 0, 0, 526, 527, 3, 43, 21, 0, 527, 528, 3, 45, 22, 0, 528, 529, 3, 41, 20, 0, 529, 128, 1, 0, 0, 0, 530, 531, 3, 49, 24, 0, 531, 532, 3, 9, 4, 0, 532, 533, 3, 23, 11, 0, 533, 534, 3, 33, 16, 0, 534, 130, 1, 0, 0, 0, 535, 536, 3, 45, 22, 0, 536, 537, 3, 43, 21, 0, 537, 132, 1, 0, 0, 0, 538, 539, 3, 45, 22, 0, 539, 540, 3, 43, 21, 0, 540, 541, 3, 45, 22, 0, 541, 542, 3, 57, 28, 0, 542, 134, 1, 0, 0, 0, 543, 544, 3, 23, 11, 0, 544, 545, 3, 55, 27, 0, 545, 546, 3, 15, 7, 0, 546, 547, 3, 7, 3, 0, 547, 548, 3, 41, 20, 0, 548, 136, 1, 0, 0, 0, 549, 550, 3, 23, 11, 0, 550, 551, 3, 13, 6, 0, 551, 552, 3, 7, 3, 0, 552, 553, 3, 55, 27, 0, 553, 138, 1, 0, 0, 0, 554, 555, 3, 13, 6, 0, 555, 556, 3, 15, 7, 0, 556, 557, 3, 11, 5, 0, 557, 140, 1, 0, 0, 0, 558, 559, 3, 37, 18, 0, 559, 560, 3, 45, 22, 0, 560, 561, 3, 43, 21, 0, 561, 142, 1, 0, 0, 0, 562, 563, 3, 37, 18, 0, 563, 564, 3, 45, 22, 0, 564, 565, 3, 43, 21, 0, 565, 566, 3, 45, 22, 0, 566, 567, 3, 57, 28, 0, 567, 144, 1, 0, 0, 0, 568, 569, 3, 17, 8, 0, 569, 570, 3, 11, 5, 0, 570, 571, 3, 21, 10, 0, 571, 572, 3, 7, 3, 0, 572, 573, 3, 41, 20, 0, 573, 146, 1, 0, 0, 0, 574, 575, 3, 49, 24, 0, 575, 576, 3, 11, 5, 0, 576, 577, 3, 21, 10, 0, 577, 578, 3, 7, 3, 0, 578, 579, 3, 41, 20, 0, 579, 148, 1, 0, 0, 0, 580, 581, 3, 17, 8, 0, 581, 582, 3, 9, 4, 0, 582, 583, 3, 23, 11, 0, 583, 584, 3, 33, 16, 0, 584, 150, 1, 0, 0, 0, 585, 586, 5, 58, 0, 0, 586, 587, 5, 58, 0, 0, 587, 152, 1, 0, 0, 0, 588, 592, 7, 32, 0, 0, 589, 591, 7, 33, 0, 0, 590, 589, 1, 0, 0, 0, 591, 594, 1, 0, 0, 0, 592, 590, 1, 0, 0, 0, 592, 593, 1, 0, 0, 0, 593, 154, 1, 0, 0, 0, 594, 592, 1, 0, 0, 0, 595, 596, 5, 60, 0, 0, 596, 156, 1, 0, 0, 0, 597, 598, 5, 62, 0, 0, 598, 158, 1, 0, 0, 0, 599, 600, 5, 40, 0, 0, 600, 160, 1, 0, 0, 0, 601, 602, 5, 41, 0, 0, 602, 162, 1, 0, 0, 0, 603, 604, 5, 91, 0, 0, 604, 164, 1, 0, 0, 0, 605, 606, 5, 93, 0, 0, 606, 166, 1, 0, 0, 0, 607, 608, 5, 44, 0, 0, 608, 168, 1, 0, 0, 0, 609, 610, 5, 61, 0, 0, 610, 170, 1, 0, 0, 0, 611, 612, 5, 58, 0, 0, 612, 172, 1, 0, 0, 0, 613, 614, 5, 63, 0, 0, 614, 174, 1, 0, 0, 0, 615, 616, 5, 35, 0, 0, 616, 176, 1, 0, 0, 0, 617, 618, 5, 46, 0, 0, 618, 178, 1, 0, 0, 0, 9, 0, 185, 197, 200, 205, 216, 279, 282, 592, 1, 0, 1, 0] \ No newline at end of file +[4, 0, 62, 630, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 186, 8, 0, 10, 0, 12, 0, 189, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, 198, 8, 1, 11, 1, 12, 1, 199, 1, 1, 3, 1, 203, 8, 1, 1, 1, 5, 1, 206, 8, 1, 10, 1, 12, 1, 209, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 2, 217, 8, 2, 11, 2, 12, 2, 218, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 5, 30, 280, 8, 30, 10, 30, 12, 30, 283, 9, 30, 3, 30, 285, 8, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 5, 77, 602, 8, 77, 10, 77, 12, 77, 605, 9, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 80, 1, 80, 1, 81, 1, 81, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 0, 0, 90, 1, 1, 3, 2, 5, 3, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0, 17, 0, 19, 0, 21, 0, 23, 0, 25, 0, 27, 0, 29, 0, 31, 0, 33, 0, 35, 0, 37, 0, 39, 0, 41, 0, 43, 0, 45, 0, 47, 0, 49, 0, 51, 0, 53, 0, 55, 0, 57, 0, 59, 0, 61, 0, 63, 4, 65, 5, 67, 6, 69, 7, 71, 8, 73, 9, 75, 10, 77, 11, 79, 12, 81, 13, 83, 14, 85, 15, 87, 16, 89, 17, 91, 18, 93, 19, 95, 20, 97, 21, 99, 22, 101, 23, 103, 24, 105, 25, 107, 26, 109, 27, 111, 28, 113, 29, 115, 30, 117, 31, 119, 32, 121, 33, 123, 34, 125, 35, 127, 36, 129, 37, 131, 38, 133, 39, 135, 40, 137, 41, 139, 42, 141, 43, 143, 44, 145, 45, 147, 46, 149, 47, 151, 48, 153, 49, 155, 50, 157, 51, 159, 52, 161, 53, 163, 54, 165, 55, 167, 56, 169, 57, 171, 58, 173, 59, 175, 60, 177, 61, 179, 62, 1, 0, 34, 2, 0, 10, 10, 13, 13, 1, 0, 42, 42, 2, 0, 42, 42, 47, 47, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 69, 69, 101, 101, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 1, 0, 48, 57, 1, 0, 49, 57, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 609, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 1, 181, 1, 0, 0, 0, 3, 192, 1, 0, 0, 0, 5, 216, 1, 0, 0, 0, 7, 222, 1, 0, 0, 0, 9, 224, 1, 0, 0, 0, 11, 226, 1, 0, 0, 0, 13, 228, 1, 0, 0, 0, 15, 230, 1, 0, 0, 0, 17, 232, 1, 0, 0, 0, 19, 234, 1, 0, 0, 0, 21, 236, 1, 0, 0, 0, 23, 238, 1, 0, 0, 0, 25, 240, 1, 0, 0, 0, 27, 242, 1, 0, 0, 0, 29, 244, 1, 0, 0, 0, 31, 246, 1, 0, 0, 0, 33, 248, 1, 0, 0, 0, 35, 250, 1, 0, 0, 0, 37, 252, 1, 0, 0, 0, 39, 254, 1, 0, 0, 0, 41, 256, 1, 0, 0, 0, 43, 258, 1, 0, 0, 0, 45, 260, 1, 0, 0, 0, 47, 262, 1, 0, 0, 0, 49, 264, 1, 0, 0, 0, 51, 266, 1, 0, 0, 0, 53, 268, 1, 0, 0, 0, 55, 270, 1, 0, 0, 0, 57, 272, 1, 0, 0, 0, 59, 274, 1, 0, 0, 0, 61, 284, 1, 0, 0, 0, 63, 286, 1, 0, 0, 0, 65, 289, 1, 0, 0, 0, 67, 294, 1, 0, 0, 0, 69, 299, 1, 0, 0, 0, 71, 307, 1, 0, 0, 0, 73, 310, 1, 0, 0, 0, 75, 314, 1, 0, 0, 0, 77, 318, 1, 0, 0, 0, 79, 322, 1, 0, 0, 0, 81, 327, 1, 0, 0, 0, 83, 332, 1, 0, 0, 0, 85, 339, 1, 0, 0, 0, 87, 346, 1, 0, 0, 0, 89, 356, 1, 0, 0, 0, 91, 369, 1, 0, 0, 0, 93, 374, 1, 0, 0, 0, 95, 379, 1, 0, 0, 0, 97, 393, 1, 0, 0, 0, 99, 406, 1, 0, 0, 0, 101, 411, 1, 0, 0, 0, 103, 419, 1, 0, 0, 0, 105, 439, 1, 0, 0, 0, 107, 462, 1, 0, 0, 0, 109, 472, 1, 0, 0, 0, 111, 480, 1, 0, 0, 0, 113, 492, 1, 0, 0, 0, 115, 499, 1, 0, 0, 0, 117, 507, 1, 0, 0, 0, 119, 512, 1, 0, 0, 0, 121, 516, 1, 0, 0, 0, 123, 520, 1, 0, 0, 0, 125, 523, 1, 0, 0, 0, 127, 532, 1, 0, 0, 0, 129, 537, 1, 0, 0, 0, 131, 541, 1, 0, 0, 0, 133, 546, 1, 0, 0, 0, 135, 549, 1, 0, 0, 0, 137, 554, 1, 0, 0, 0, 139, 560, 1, 0, 0, 0, 141, 565, 1, 0, 0, 0, 143, 569, 1, 0, 0, 0, 145, 573, 1, 0, 0, 0, 147, 579, 1, 0, 0, 0, 149, 585, 1, 0, 0, 0, 151, 591, 1, 0, 0, 0, 153, 596, 1, 0, 0, 0, 155, 599, 1, 0, 0, 0, 157, 606, 1, 0, 0, 0, 159, 608, 1, 0, 0, 0, 161, 610, 1, 0, 0, 0, 163, 612, 1, 0, 0, 0, 165, 614, 1, 0, 0, 0, 167, 616, 1, 0, 0, 0, 169, 618, 1, 0, 0, 0, 171, 620, 1, 0, 0, 0, 173, 622, 1, 0, 0, 0, 175, 624, 1, 0, 0, 0, 177, 626, 1, 0, 0, 0, 179, 628, 1, 0, 0, 0, 181, 182, 5, 47, 0, 0, 182, 183, 5, 47, 0, 0, 183, 187, 1, 0, 0, 0, 184, 186, 8, 0, 0, 0, 185, 184, 1, 0, 0, 0, 186, 189, 1, 0, 0, 0, 187, 185, 1, 0, 0, 0, 187, 188, 1, 0, 0, 0, 188, 190, 1, 0, 0, 0, 189, 187, 1, 0, 0, 0, 190, 191, 6, 0, 0, 0, 191, 2, 1, 0, 0, 0, 192, 193, 5, 47, 0, 0, 193, 194, 5, 42, 0, 0, 194, 202, 1, 0, 0, 0, 195, 203, 8, 1, 0, 0, 196, 198, 5, 42, 0, 0, 197, 196, 1, 0, 0, 0, 198, 199, 1, 0, 0, 0, 199, 197, 1, 0, 0, 0, 199, 200, 1, 0, 0, 0, 200, 201, 1, 0, 0, 0, 201, 203, 8, 2, 0, 0, 202, 195, 1, 0, 0, 0, 202, 197, 1, 0, 0, 0, 203, 207, 1, 0, 0, 0, 204, 206, 5, 42, 0, 0, 205, 204, 1, 0, 0, 0, 206, 209, 1, 0, 0, 0, 207, 205, 1, 0, 0, 0, 207, 208, 1, 0, 0, 0, 208, 210, 1, 0, 0, 0, 209, 207, 1, 0, 0, 0, 210, 211, 5, 42, 0, 0, 211, 212, 5, 47, 0, 0, 212, 213, 1, 0, 0, 0, 213, 214, 6, 1, 0, 0, 214, 4, 1, 0, 0, 0, 215, 217, 7, 3, 0, 0, 216, 215, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 216, 1, 0, 0, 0, 218, 219, 1, 0, 0, 0, 219, 220, 1, 0, 0, 0, 220, 221, 6, 2, 0, 0, 221, 6, 1, 0, 0, 0, 222, 223, 7, 4, 0, 0, 223, 8, 1, 0, 0, 0, 224, 225, 7, 5, 0, 0, 225, 10, 1, 0, 0, 0, 226, 227, 7, 6, 0, 0, 227, 12, 1, 0, 0, 0, 228, 229, 7, 7, 0, 0, 229, 14, 1, 0, 0, 0, 230, 231, 7, 8, 0, 0, 231, 16, 1, 0, 0, 0, 232, 233, 7, 9, 0, 0, 233, 18, 1, 0, 0, 0, 234, 235, 7, 10, 0, 0, 235, 20, 1, 0, 0, 0, 236, 237, 7, 11, 0, 0, 237, 22, 1, 0, 0, 0, 238, 239, 7, 12, 0, 0, 239, 24, 1, 0, 0, 0, 240, 241, 7, 13, 0, 0, 241, 26, 1, 0, 0, 0, 242, 243, 7, 14, 0, 0, 243, 28, 1, 0, 0, 0, 244, 245, 7, 15, 0, 0, 245, 30, 1, 0, 0, 0, 246, 247, 7, 16, 0, 0, 247, 32, 1, 0, 0, 0, 248, 249, 7, 17, 0, 0, 249, 34, 1, 0, 0, 0, 250, 251, 7, 18, 0, 0, 251, 36, 1, 0, 0, 0, 252, 253, 7, 19, 0, 0, 253, 38, 1, 0, 0, 0, 254, 255, 7, 20, 0, 0, 255, 40, 1, 0, 0, 0, 256, 257, 7, 21, 0, 0, 257, 42, 1, 0, 0, 0, 258, 259, 7, 22, 0, 0, 259, 44, 1, 0, 0, 0, 260, 261, 7, 23, 0, 0, 261, 46, 1, 0, 0, 0, 262, 263, 7, 24, 0, 0, 263, 48, 1, 0, 0, 0, 264, 265, 7, 25, 0, 0, 265, 50, 1, 0, 0, 0, 266, 267, 7, 26, 0, 0, 267, 52, 1, 0, 0, 0, 268, 269, 7, 27, 0, 0, 269, 54, 1, 0, 0, 0, 270, 271, 7, 28, 0, 0, 271, 56, 1, 0, 0, 0, 272, 273, 7, 29, 0, 0, 273, 58, 1, 0, 0, 0, 274, 275, 7, 30, 0, 0, 275, 60, 1, 0, 0, 0, 276, 285, 5, 48, 0, 0, 277, 281, 7, 31, 0, 0, 278, 280, 7, 30, 0, 0, 279, 278, 1, 0, 0, 0, 280, 283, 1, 0, 0, 0, 281, 279, 1, 0, 0, 0, 281, 282, 1, 0, 0, 0, 282, 285, 1, 0, 0, 0, 283, 281, 1, 0, 0, 0, 284, 276, 1, 0, 0, 0, 284, 277, 1, 0, 0, 0, 285, 62, 1, 0, 0, 0, 286, 287, 3, 23, 11, 0, 287, 288, 3, 17, 8, 0, 288, 64, 1, 0, 0, 0, 289, 290, 3, 45, 22, 0, 290, 291, 3, 21, 10, 0, 291, 292, 3, 15, 7, 0, 292, 293, 3, 33, 16, 0, 293, 66, 1, 0, 0, 0, 294, 295, 3, 15, 7, 0, 295, 296, 3, 29, 14, 0, 296, 297, 3, 43, 21, 0, 297, 298, 3, 15, 7, 0, 298, 68, 1, 0, 0, 0, 299, 300, 3, 9, 4, 0, 300, 301, 3, 35, 17, 0, 301, 302, 3, 35, 17, 0, 302, 303, 3, 29, 14, 0, 303, 304, 3, 15, 7, 0, 304, 305, 3, 7, 3, 0, 305, 306, 3, 33, 16, 0, 306, 70, 1, 0, 0, 0, 307, 308, 3, 23, 11, 0, 308, 309, 5, 56, 0, 0, 309, 72, 1, 0, 0, 0, 310, 311, 3, 23, 11, 0, 311, 312, 5, 49, 0, 0, 312, 313, 5, 54, 0, 0, 313, 74, 1, 0, 0, 0, 314, 315, 3, 23, 11, 0, 315, 316, 5, 51, 0, 0, 316, 317, 5, 50, 0, 0, 317, 76, 1, 0, 0, 0, 318, 319, 3, 23, 11, 0, 319, 320, 5, 54, 0, 0, 320, 321, 5, 52, 0, 0, 321, 78, 1, 0, 0, 0, 322, 323, 3, 17, 8, 0, 323, 324, 3, 37, 18, 0, 324, 325, 5, 51, 0, 0, 325, 326, 5, 50, 0, 0, 326, 80, 1, 0, 0, 0, 327, 328, 3, 17, 8, 0, 328, 329, 3, 37, 18, 0, 329, 330, 5, 54, 0, 0, 330, 331, 5, 52, 0, 0, 331, 82, 1, 0, 0, 0, 332, 333, 3, 43, 21, 0, 333, 334, 3, 45, 22, 0, 334, 335, 3, 41, 20, 0, 335, 336, 3, 23, 11, 0, 336, 337, 3, 33, 16, 0, 337, 338, 3, 19, 9, 0, 338, 84, 1, 0, 0, 0, 339, 340, 3, 9, 4, 0, 340, 341, 3, 23, 11, 0, 341, 342, 3, 33, 16, 0, 342, 343, 3, 7, 3, 0, 343, 344, 3, 41, 20, 0, 344, 345, 3, 55, 27, 0, 345, 86, 1, 0, 0, 0, 346, 347, 3, 45, 22, 0, 347, 348, 3, 23, 11, 0, 348, 349, 3, 31, 15, 0, 349, 350, 3, 15, 7, 0, 350, 351, 3, 43, 21, 0, 351, 352, 3, 45, 22, 0, 352, 353, 3, 7, 3, 0, 353, 354, 3, 31, 15, 0, 354, 355, 3, 37, 18, 0, 355, 88, 1, 0, 0, 0, 356, 357, 3, 45, 22, 0, 357, 358, 3, 23, 11, 0, 358, 359, 3, 31, 15, 0, 359, 360, 3, 15, 7, 0, 360, 361, 3, 43, 21, 0, 361, 362, 3, 45, 22, 0, 362, 363, 3, 7, 3, 0, 363, 364, 3, 31, 15, 0, 364, 365, 3, 37, 18, 0, 365, 366, 5, 95, 0, 0, 366, 367, 3, 45, 22, 0, 367, 368, 3, 57, 28, 0, 368, 90, 1, 0, 0, 0, 369, 370, 3, 13, 6, 0, 370, 371, 3, 7, 3, 0, 371, 372, 3, 45, 22, 0, 372, 373, 3, 15, 7, 0, 373, 92, 1, 0, 0, 0, 374, 375, 3, 45, 22, 0, 375, 376, 3, 23, 11, 0, 376, 377, 3, 31, 15, 0, 377, 378, 3, 15, 7, 0, 378, 94, 1, 0, 0, 0, 379, 380, 3, 23, 11, 0, 380, 381, 3, 33, 16, 0, 381, 382, 3, 45, 22, 0, 382, 383, 3, 15, 7, 0, 383, 384, 3, 41, 20, 0, 384, 385, 3, 49, 24, 0, 385, 386, 3, 7, 3, 0, 386, 387, 3, 29, 14, 0, 387, 388, 5, 95, 0, 0, 388, 389, 3, 55, 27, 0, 389, 390, 3, 15, 7, 0, 390, 391, 3, 7, 3, 0, 391, 392, 3, 41, 20, 0, 392, 96, 1, 0, 0, 0, 393, 394, 3, 23, 11, 0, 394, 395, 3, 33, 16, 0, 395, 396, 3, 45, 22, 0, 396, 397, 3, 15, 7, 0, 397, 398, 3, 41, 20, 0, 398, 399, 3, 49, 24, 0, 399, 400, 3, 7, 3, 0, 400, 401, 3, 29, 14, 0, 401, 402, 5, 95, 0, 0, 402, 403, 3, 13, 6, 0, 403, 404, 3, 7, 3, 0, 404, 405, 3, 55, 27, 0, 405, 98, 1, 0, 0, 0, 406, 407, 3, 47, 23, 0, 407, 408, 3, 47, 23, 0, 408, 409, 3, 23, 11, 0, 409, 410, 3, 13, 6, 0, 410, 100, 1, 0, 0, 0, 411, 412, 3, 13, 6, 0, 412, 413, 3, 15, 7, 0, 413, 414, 3, 11, 5, 0, 414, 415, 3, 23, 11, 0, 415, 416, 3, 31, 15, 0, 416, 417, 3, 7, 3, 0, 417, 418, 3, 29, 14, 0, 418, 102, 1, 0, 0, 0, 419, 420, 3, 37, 18, 0, 420, 421, 3, 41, 20, 0, 421, 422, 3, 15, 7, 0, 422, 423, 3, 11, 5, 0, 423, 424, 3, 23, 11, 0, 424, 425, 3, 43, 21, 0, 425, 426, 3, 23, 11, 0, 426, 427, 3, 35, 17, 0, 427, 428, 3, 33, 16, 0, 428, 429, 5, 95, 0, 0, 429, 430, 3, 45, 22, 0, 430, 431, 3, 23, 11, 0, 431, 432, 3, 31, 15, 0, 432, 433, 3, 15, 7, 0, 433, 434, 3, 43, 21, 0, 434, 435, 3, 45, 22, 0, 435, 436, 3, 7, 3, 0, 436, 437, 3, 31, 15, 0, 437, 438, 3, 37, 18, 0, 438, 104, 1, 0, 0, 0, 439, 440, 3, 37, 18, 0, 440, 441, 3, 41, 20, 0, 441, 442, 3, 15, 7, 0, 442, 443, 3, 11, 5, 0, 443, 444, 3, 23, 11, 0, 444, 445, 3, 43, 21, 0, 445, 446, 3, 23, 11, 0, 446, 447, 3, 35, 17, 0, 447, 448, 3, 33, 16, 0, 448, 449, 5, 95, 0, 0, 449, 450, 3, 45, 22, 0, 450, 451, 3, 23, 11, 0, 451, 452, 3, 31, 15, 0, 452, 453, 3, 15, 7, 0, 453, 454, 3, 43, 21, 0, 454, 455, 3, 45, 22, 0, 455, 456, 3, 7, 3, 0, 456, 457, 3, 31, 15, 0, 457, 458, 3, 37, 18, 0, 458, 459, 5, 95, 0, 0, 459, 460, 3, 45, 22, 0, 460, 461, 3, 57, 28, 0, 461, 106, 1, 0, 0, 0, 462, 463, 3, 17, 8, 0, 463, 464, 3, 23, 11, 0, 464, 465, 3, 53, 26, 0, 465, 466, 3, 15, 7, 0, 466, 467, 3, 13, 6, 0, 467, 468, 3, 11, 5, 0, 468, 469, 3, 21, 10, 0, 469, 470, 3, 7, 3, 0, 470, 471, 3, 41, 20, 0, 471, 108, 1, 0, 0, 0, 472, 473, 3, 49, 24, 0, 473, 474, 3, 7, 3, 0, 474, 475, 3, 41, 20, 0, 475, 476, 3, 11, 5, 0, 476, 477, 3, 21, 10, 0, 477, 478, 3, 7, 3, 0, 478, 479, 3, 41, 20, 0, 479, 110, 1, 0, 0, 0, 480, 481, 3, 17, 8, 0, 481, 482, 3, 23, 11, 0, 482, 483, 3, 53, 26, 0, 483, 484, 3, 15, 7, 0, 484, 485, 3, 13, 6, 0, 485, 486, 3, 9, 4, 0, 486, 487, 3, 23, 11, 0, 487, 488, 3, 33, 16, 0, 488, 489, 3, 7, 3, 0, 489, 490, 3, 41, 20, 0, 490, 491, 3, 55, 27, 0, 491, 112, 1, 0, 0, 0, 492, 493, 3, 43, 21, 0, 493, 494, 3, 45, 22, 0, 494, 495, 3, 41, 20, 0, 495, 496, 3, 47, 23, 0, 496, 497, 3, 11, 5, 0, 497, 498, 3, 45, 22, 0, 498, 114, 1, 0, 0, 0, 499, 500, 3, 33, 16, 0, 500, 501, 3, 43, 21, 0, 501, 502, 3, 45, 22, 0, 502, 503, 3, 41, 20, 0, 503, 504, 3, 47, 23, 0, 504, 505, 3, 11, 5, 0, 505, 506, 3, 45, 22, 0, 506, 116, 1, 0, 0, 0, 507, 508, 3, 29, 14, 0, 508, 509, 3, 23, 11, 0, 509, 510, 3, 43, 21, 0, 510, 511, 3, 45, 22, 0, 511, 118, 1, 0, 0, 0, 512, 513, 3, 31, 15, 0, 513, 514, 3, 7, 3, 0, 514, 515, 3, 37, 18, 0, 515, 120, 1, 0, 0, 0, 516, 517, 3, 7, 3, 0, 517, 518, 3, 33, 16, 0, 518, 519, 3, 55, 27, 0, 519, 122, 1, 0, 0, 0, 520, 521, 3, 47, 23, 0, 521, 522, 5, 33, 0, 0, 522, 124, 1, 0, 0, 0, 523, 524, 3, 19, 9, 0, 524, 525, 3, 15, 7, 0, 525, 526, 3, 35, 17, 0, 526, 527, 3, 31, 15, 0, 527, 528, 3, 15, 7, 0, 528, 529, 3, 45, 22, 0, 529, 530, 3, 41, 20, 0, 530, 531, 3, 55, 27, 0, 531, 126, 1, 0, 0, 0, 532, 533, 3, 9, 4, 0, 533, 534, 3, 35, 17, 0, 534, 535, 3, 35, 17, 0, 535, 536, 3, 29, 14, 0, 536, 128, 1, 0, 0, 0, 537, 538, 3, 43, 21, 0, 538, 539, 3, 45, 22, 0, 539, 540, 3, 41, 20, 0, 540, 130, 1, 0, 0, 0, 541, 542, 3, 49, 24, 0, 542, 543, 3, 9, 4, 0, 543, 544, 3, 23, 11, 0, 544, 545, 3, 33, 16, 0, 545, 132, 1, 0, 0, 0, 546, 547, 3, 45, 22, 0, 547, 548, 3, 43, 21, 0, 548, 134, 1, 0, 0, 0, 549, 550, 3, 45, 22, 0, 550, 551, 3, 43, 21, 0, 551, 552, 3, 45, 22, 0, 552, 553, 3, 57, 28, 0, 553, 136, 1, 0, 0, 0, 554, 555, 3, 23, 11, 0, 555, 556, 3, 55, 27, 0, 556, 557, 3, 15, 7, 0, 557, 558, 3, 7, 3, 0, 558, 559, 3, 41, 20, 0, 559, 138, 1, 0, 0, 0, 560, 561, 3, 23, 11, 0, 561, 562, 3, 13, 6, 0, 562, 563, 3, 7, 3, 0, 563, 564, 3, 55, 27, 0, 564, 140, 1, 0, 0, 0, 565, 566, 3, 13, 6, 0, 566, 567, 3, 15, 7, 0, 567, 568, 3, 11, 5, 0, 568, 142, 1, 0, 0, 0, 569, 570, 3, 37, 18, 0, 570, 571, 3, 45, 22, 0, 571, 572, 3, 43, 21, 0, 572, 144, 1, 0, 0, 0, 573, 574, 3, 37, 18, 0, 574, 575, 3, 45, 22, 0, 575, 576, 3, 43, 21, 0, 576, 577, 3, 45, 22, 0, 577, 578, 3, 57, 28, 0, 578, 146, 1, 0, 0, 0, 579, 580, 3, 17, 8, 0, 580, 581, 3, 11, 5, 0, 581, 582, 3, 21, 10, 0, 582, 583, 3, 7, 3, 0, 583, 584, 3, 41, 20, 0, 584, 148, 1, 0, 0, 0, 585, 586, 3, 49, 24, 0, 586, 587, 3, 11, 5, 0, 587, 588, 3, 21, 10, 0, 588, 589, 3, 7, 3, 0, 589, 590, 3, 41, 20, 0, 590, 150, 1, 0, 0, 0, 591, 592, 3, 17, 8, 0, 592, 593, 3, 9, 4, 0, 593, 594, 3, 23, 11, 0, 594, 595, 3, 33, 16, 0, 595, 152, 1, 0, 0, 0, 596, 597, 5, 58, 0, 0, 597, 598, 5, 58, 0, 0, 598, 154, 1, 0, 0, 0, 599, 603, 7, 32, 0, 0, 600, 602, 7, 33, 0, 0, 601, 600, 1, 0, 0, 0, 602, 605, 1, 0, 0, 0, 603, 601, 1, 0, 0, 0, 603, 604, 1, 0, 0, 0, 604, 156, 1, 0, 0, 0, 605, 603, 1, 0, 0, 0, 606, 607, 5, 60, 0, 0, 607, 158, 1, 0, 0, 0, 608, 609, 5, 62, 0, 0, 609, 160, 1, 0, 0, 0, 610, 611, 5, 40, 0, 0, 611, 162, 1, 0, 0, 0, 612, 613, 5, 41, 0, 0, 613, 164, 1, 0, 0, 0, 614, 615, 5, 91, 0, 0, 615, 166, 1, 0, 0, 0, 616, 617, 5, 93, 0, 0, 617, 168, 1, 0, 0, 0, 618, 619, 5, 44, 0, 0, 619, 170, 1, 0, 0, 0, 620, 621, 5, 61, 0, 0, 621, 172, 1, 0, 0, 0, 622, 623, 5, 58, 0, 0, 623, 174, 1, 0, 0, 0, 624, 625, 5, 63, 0, 0, 625, 176, 1, 0, 0, 0, 626, 627, 5, 35, 0, 0, 627, 178, 1, 0, 0, 0, 628, 629, 5, 46, 0, 0, 629, 180, 1, 0, 0, 0, 9, 0, 187, 199, 202, 207, 218, 281, 284, 603, 1, 0, 1, 0] \ No newline at end of file diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py index 081a1e211..fad7b27f0 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.py +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -1,14 +1,7 @@ -# SPDX-License-Identifier: Apache-2.0 # Generated from SubstraitLexer.g4 by ANTLR 4.13.2 -from antlr4 import ( - ATNDeserializer, - DFA, - Lexer, - LexerATNSimulator, - PredictionContextCache, -) +from antlr4 import * +from io import StringIO import sys - if sys.version_info[1] > 5: from typing import TextIO else: @@ -17,5263 +10,234 @@ def serializedATN(): return [ - 4, - 0, - 61, - 619, - 6, - -1, - 2, - 0, - 7, - 0, - 2, - 1, - 7, - 1, - 2, - 2, - 7, - 2, - 2, - 3, - 7, - 3, - 2, - 4, - 7, - 4, - 2, - 5, - 7, - 5, - 2, - 6, - 7, - 6, - 2, - 7, - 7, - 7, - 2, - 8, - 7, - 8, - 2, - 9, - 7, - 9, - 2, - 10, - 7, - 10, - 2, - 11, - 7, - 11, - 2, - 12, - 7, - 12, - 2, - 13, - 7, - 13, - 2, - 14, - 7, - 14, - 2, - 15, - 7, - 15, - 2, - 16, - 7, - 16, - 2, - 17, - 7, - 17, - 2, - 18, - 7, - 18, - 2, - 19, - 7, - 19, - 2, - 20, - 7, - 20, - 2, - 21, - 7, - 21, - 2, - 22, - 7, - 22, - 2, - 23, - 7, - 23, - 2, - 24, - 7, - 24, - 2, - 25, - 7, - 25, - 2, - 26, - 7, - 26, - 2, - 27, - 7, - 27, - 2, - 28, - 7, - 28, - 2, - 29, - 7, - 29, - 2, - 30, - 7, - 30, - 2, - 31, - 7, - 31, - 2, - 32, - 7, - 32, - 2, - 33, - 7, - 33, - 2, - 34, - 7, - 34, - 2, - 35, - 7, - 35, - 2, - 36, - 7, - 36, - 2, - 37, - 7, - 37, - 2, - 38, - 7, - 38, - 2, - 39, - 7, - 39, - 2, - 40, - 7, - 40, - 2, - 41, - 7, - 41, - 2, - 42, - 7, - 42, - 2, - 43, - 7, - 43, - 2, - 44, - 7, - 44, - 2, - 45, - 7, - 45, - 2, - 46, - 7, - 46, - 2, - 47, - 7, - 47, - 2, - 48, - 7, - 48, - 2, - 49, - 7, - 49, - 2, - 50, - 7, - 50, - 2, - 51, - 7, - 51, - 2, - 52, - 7, - 52, - 2, - 53, - 7, - 53, - 2, - 54, - 7, - 54, - 2, - 55, - 7, - 55, - 2, - 56, - 7, - 56, - 2, - 57, - 7, - 57, - 2, - 58, - 7, - 58, - 2, - 59, - 7, - 59, - 2, - 60, - 7, - 60, - 2, - 61, - 7, - 61, - 2, - 62, - 7, - 62, - 2, - 63, - 7, - 63, - 2, - 64, - 7, - 64, - 2, - 65, - 7, - 65, - 2, - 66, - 7, - 66, - 2, - 67, - 7, - 67, - 2, - 68, - 7, - 68, - 2, - 69, - 7, - 69, - 2, - 70, - 7, - 70, - 2, - 71, - 7, - 71, - 2, - 72, - 7, - 72, - 2, - 73, - 7, - 73, - 2, - 74, - 7, - 74, - 2, - 75, - 7, - 75, - 2, - 76, - 7, - 76, - 2, - 77, - 7, - 77, - 2, - 78, - 7, - 78, - 2, - 79, - 7, - 79, - 2, - 80, - 7, - 80, - 2, - 81, - 7, - 81, - 2, - 82, - 7, - 82, - 2, - 83, - 7, - 83, - 2, - 84, - 7, - 84, - 2, - 85, - 7, - 85, - 2, - 86, - 7, - 86, - 2, - 87, - 7, - 87, - 2, - 88, - 7, - 88, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 5, - 0, - 184, - 8, - 0, - 10, - 0, - 12, - 0, - 187, - 9, - 0, - 1, - 0, - 1, - 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 4, - 1, - 196, - 8, - 1, - 11, - 1, - 12, - 1, - 197, - 1, - 1, - 3, - 1, - 201, - 8, - 1, - 1, - 1, - 5, - 1, - 204, - 8, - 1, - 10, - 1, - 12, - 1, - 207, - 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 2, - 4, - 2, - 215, - 8, - 2, - 11, - 2, - 12, - 2, - 216, - 1, - 2, - 1, - 2, - 1, - 3, - 1, - 3, - 1, - 4, - 1, - 4, - 1, - 5, - 1, - 5, - 1, - 6, - 1, - 6, - 1, - 7, - 1, - 7, - 1, - 8, - 1, - 8, - 1, - 9, - 1, - 9, - 1, - 10, - 1, - 10, - 1, - 11, - 1, - 11, - 1, - 12, - 1, - 12, - 1, - 13, - 1, - 13, - 1, - 14, - 1, - 14, - 1, - 15, - 1, - 15, - 1, - 16, - 1, - 16, - 1, - 17, - 1, - 17, - 1, - 18, - 1, - 18, - 1, - 19, - 1, - 19, - 1, - 20, - 1, - 20, - 1, - 21, - 1, - 21, - 1, - 22, - 1, - 22, - 1, - 23, - 1, - 23, - 1, - 24, - 1, - 24, - 1, - 25, - 1, - 25, - 1, - 26, - 1, - 26, - 1, - 27, - 1, - 27, - 1, - 28, - 1, - 28, - 1, - 29, - 1, - 29, - 1, - 30, - 1, - 30, - 1, - 30, - 5, - 30, - 278, - 8, - 30, - 10, - 30, - 12, - 30, - 281, - 9, - 30, - 3, - 30, - 283, - 8, - 30, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 35, - 1, - 35, - 1, - 35, - 1, - 36, - 1, - 36, - 1, - 36, - 1, - 36, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 38, - 1, - 38, - 1, - 38, - 1, - 38, - 1, - 39, - 1, - 39, - 1, - 39, - 1, - 39, - 1, - 39, - 1, - 40, - 1, - 40, - 1, - 40, - 1, - 40, - 1, - 40, - 1, - 41, - 1, - 41, - 1, - 41, - 1, - 41, - 1, - 41, - 1, - 41, - 1, - 41, - 1, - 42, - 1, - 42, - 1, - 42, - 1, - 42, - 1, - 42, - 1, - 42, - 1, - 42, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 43, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 44, - 1, - 45, - 1, - 45, - 1, - 45, - 1, - 45, - 1, - 45, - 1, - 46, - 1, - 46, - 1, - 46, - 1, - 46, - 1, - 46, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 47, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 48, - 1, - 49, - 1, - 49, - 1, - 49, - 1, - 49, - 1, - 49, - 1, - 50, - 1, - 50, - 1, - 50, - 1, - 50, - 1, - 50, - 1, - 50, - 1, - 50, - 1, - 50, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 51, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 52, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 53, - 1, - 54, - 1, - 54, - 1, - 54, - 1, - 54, - 1, - 54, - 1, - 54, - 1, - 54, - 1, - 54, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 55, - 1, - 56, - 1, - 56, - 1, - 56, - 1, - 56, - 1, - 56, - 1, - 56, - 1, - 56, - 1, - 57, - 1, - 57, - 1, - 57, - 1, - 57, - 1, - 57, - 1, - 57, - 1, - 57, - 1, - 57, - 1, - 58, - 1, - 58, - 1, - 58, - 1, - 58, - 1, - 58, - 1, - 59, - 1, - 59, - 1, - 59, - 1, - 59, - 1, - 60, - 1, - 60, - 1, - 60, - 1, - 60, - 1, - 61, - 1, - 61, - 1, - 61, - 1, - 62, - 1, - 62, - 1, - 62, - 1, - 62, - 1, - 62, - 1, - 63, - 1, - 63, - 1, - 63, - 1, - 63, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 64, - 1, - 65, - 1, - 65, - 1, - 65, - 1, - 66, - 1, - 66, - 1, - 66, - 1, - 66, - 1, - 66, - 1, - 67, - 1, - 67, - 1, - 67, - 1, - 67, - 1, - 67, - 1, - 67, - 1, - 68, - 1, - 68, - 1, - 68, - 1, - 68, - 1, - 68, - 1, - 69, - 1, - 69, - 1, - 69, - 1, - 69, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 71, - 1, - 71, - 1, - 71, - 1, - 71, - 1, - 71, - 1, - 71, - 1, - 72, - 1, - 72, - 1, - 72, - 1, - 72, - 1, - 72, - 1, - 72, - 1, - 73, - 1, - 73, - 1, - 73, - 1, - 73, - 1, - 73, - 1, - 73, - 1, - 74, - 1, - 74, - 1, - 74, - 1, - 74, - 1, - 74, - 1, - 75, - 1, - 75, - 1, - 75, - 1, - 76, - 1, - 76, - 5, - 76, - 591, - 8, - 76, - 10, - 76, - 12, - 76, - 594, - 9, - 76, - 1, - 77, - 1, - 77, - 1, - 78, - 1, - 78, - 1, - 79, - 1, - 79, - 1, - 80, - 1, - 80, - 1, - 81, - 1, - 81, - 1, - 82, - 1, - 82, - 1, - 83, - 1, - 83, - 1, - 84, - 1, - 84, - 1, - 85, - 1, - 85, - 1, - 86, - 1, - 86, - 1, - 87, - 1, - 87, - 1, - 88, - 1, - 88, - 0, - 0, - 89, - 1, - 1, - 3, - 2, - 5, - 3, - 7, - 0, - 9, - 0, - 11, - 0, - 13, - 0, - 15, - 0, - 17, - 0, - 19, - 0, - 21, - 0, - 23, - 0, - 25, - 0, - 27, - 0, - 29, - 0, - 31, - 0, - 33, - 0, - 35, - 0, - 37, - 0, - 39, - 0, - 41, - 0, - 43, - 0, - 45, - 0, - 47, - 0, - 49, - 0, - 51, - 0, - 53, - 0, - 55, - 0, - 57, - 0, - 59, - 0, - 61, - 0, - 63, - 4, - 65, - 5, - 67, - 6, - 69, - 7, - 71, - 8, - 73, - 9, - 75, - 10, - 77, - 11, - 79, - 12, - 81, - 13, - 83, - 14, - 85, - 15, - 87, - 16, - 89, - 17, - 91, - 18, - 93, - 19, - 95, - 20, - 97, - 21, - 99, - 22, - 101, - 23, - 103, - 24, - 105, - 25, - 107, - 26, - 109, - 27, - 111, - 28, - 113, - 29, - 115, - 30, - 117, - 31, - 119, - 32, - 121, - 33, - 123, - 34, - 125, - 35, - 127, - 36, - 129, - 37, - 131, - 38, - 133, - 39, - 135, - 40, - 137, - 41, - 139, - 42, - 141, - 43, - 143, - 44, - 145, - 45, - 147, - 46, - 149, - 47, - 151, - 48, - 153, - 49, - 155, - 50, - 157, - 51, - 159, - 52, - 161, - 53, - 163, - 54, - 165, - 55, - 167, - 56, - 169, - 57, - 171, - 58, - 173, - 59, - 175, - 60, - 177, - 61, - 1, - 0, - 34, - 2, - 0, - 10, - 10, - 13, - 13, - 1, - 0, - 42, - 42, - 2, - 0, - 42, - 42, - 47, - 47, - 3, - 0, - 9, - 10, - 13, - 13, - 32, - 32, - 2, - 0, - 65, - 65, - 97, - 97, - 2, - 0, - 66, - 66, - 98, - 98, - 2, - 0, - 67, - 67, - 99, - 99, - 2, - 0, - 68, - 68, - 100, - 100, - 2, - 0, - 69, - 69, - 101, - 101, - 2, - 0, - 70, - 70, - 102, - 102, - 2, - 0, - 71, - 71, - 103, - 103, - 2, - 0, - 72, - 72, - 104, - 104, - 2, - 0, - 73, - 73, - 105, - 105, - 2, - 0, - 74, - 74, - 106, - 106, - 2, - 0, - 75, - 75, - 107, - 107, - 2, - 0, - 76, - 76, - 108, - 108, - 2, - 0, - 77, - 77, - 109, - 109, - 2, - 0, - 78, - 78, - 110, - 110, - 2, - 0, - 79, - 79, - 111, - 111, - 2, - 0, - 80, - 80, - 112, - 112, - 2, - 0, - 81, - 81, - 113, - 113, - 2, - 0, - 82, - 82, - 114, - 114, - 2, - 0, - 83, - 83, - 115, - 115, - 2, - 0, - 84, - 84, - 116, - 116, - 2, - 0, - 85, - 85, - 117, - 117, - 2, - 0, - 86, - 86, - 118, - 118, - 2, - 0, - 87, - 87, - 119, - 119, - 2, - 0, - 88, - 88, - 120, - 120, - 2, - 0, - 89, - 89, - 121, - 121, - 2, - 0, - 90, - 90, - 122, - 122, - 1, - 0, - 48, - 57, - 1, - 0, - 49, - 57, - 3, - 0, - 65, - 90, - 95, - 95, - 97, - 122, - 4, - 0, - 48, - 57, - 65, - 90, - 95, - 95, - 97, - 122, - 598, - 0, - 1, - 1, - 0, - 0, - 0, - 0, - 3, - 1, - 0, - 0, - 0, - 0, - 5, - 1, - 0, - 0, - 0, - 0, - 63, - 1, - 0, - 0, - 0, - 0, - 65, - 1, - 0, - 0, - 0, - 0, - 67, - 1, - 0, - 0, - 0, - 0, - 69, - 1, - 0, - 0, - 0, - 0, - 71, - 1, - 0, - 0, - 0, - 0, - 73, - 1, - 0, - 0, - 0, - 0, - 75, - 1, - 0, - 0, - 0, - 0, - 77, - 1, - 0, - 0, - 0, - 0, - 79, - 1, - 0, - 0, - 0, - 0, - 81, - 1, - 0, - 0, - 0, - 0, - 83, - 1, - 0, - 0, - 0, - 0, - 85, - 1, - 0, - 0, - 0, - 0, - 87, - 1, - 0, - 0, - 0, - 0, - 89, - 1, - 0, - 0, - 0, - 0, - 91, - 1, - 0, - 0, - 0, - 0, - 93, - 1, - 0, - 0, - 0, - 0, - 95, - 1, - 0, - 0, - 0, - 0, - 97, - 1, - 0, - 0, - 0, - 0, - 99, - 1, - 0, - 0, - 0, - 0, - 101, - 1, - 0, - 0, - 0, - 0, - 103, - 1, - 0, - 0, - 0, - 0, - 105, - 1, - 0, - 0, - 0, - 0, - 107, - 1, - 0, - 0, - 0, - 0, - 109, - 1, - 0, - 0, - 0, - 0, - 111, - 1, - 0, - 0, - 0, - 0, - 113, - 1, - 0, - 0, - 0, - 0, - 115, - 1, - 0, - 0, - 0, - 0, - 117, - 1, - 0, - 0, - 0, - 0, - 119, - 1, - 0, - 0, - 0, - 0, - 121, - 1, - 0, - 0, - 0, - 0, - 123, - 1, - 0, - 0, - 0, - 0, - 125, - 1, - 0, - 0, - 0, - 0, - 127, - 1, - 0, - 0, - 0, - 0, - 129, - 1, - 0, - 0, - 0, - 0, - 131, - 1, - 0, - 0, - 0, - 0, - 133, - 1, - 0, - 0, - 0, - 0, - 135, - 1, - 0, - 0, - 0, - 0, - 137, - 1, - 0, - 0, - 0, - 0, - 139, - 1, - 0, - 0, - 0, - 0, - 141, - 1, - 0, - 0, - 0, - 0, - 143, - 1, - 0, - 0, - 0, - 0, - 145, - 1, - 0, - 0, - 0, - 0, - 147, - 1, - 0, - 0, - 0, - 0, - 149, - 1, - 0, - 0, - 0, - 0, - 151, - 1, - 0, - 0, - 0, - 0, - 153, - 1, - 0, - 0, - 0, - 0, - 155, - 1, - 0, - 0, - 0, - 0, - 157, - 1, - 0, - 0, - 0, - 0, - 159, - 1, - 0, - 0, - 0, - 0, - 161, - 1, - 0, - 0, - 0, - 0, - 163, - 1, - 0, - 0, - 0, - 0, - 165, - 1, - 0, - 0, - 0, - 0, - 167, - 1, - 0, - 0, - 0, - 0, - 169, - 1, - 0, - 0, - 0, - 0, - 171, - 1, - 0, - 0, - 0, - 0, - 173, - 1, - 0, - 0, - 0, - 0, - 175, - 1, - 0, - 0, - 0, - 0, - 177, - 1, - 0, - 0, - 0, - 1, - 179, - 1, - 0, - 0, - 0, - 3, - 190, - 1, - 0, - 0, - 0, - 5, - 214, - 1, - 0, - 0, - 0, - 7, - 220, - 1, - 0, - 0, - 0, - 9, - 222, - 1, - 0, - 0, - 0, - 11, - 224, - 1, - 0, - 0, - 0, - 13, - 226, - 1, - 0, - 0, - 0, - 15, - 228, - 1, - 0, - 0, - 0, - 17, - 230, - 1, - 0, - 0, - 0, - 19, - 232, - 1, - 0, - 0, - 0, - 21, - 234, - 1, - 0, - 0, - 0, - 23, - 236, - 1, - 0, - 0, - 0, - 25, - 238, - 1, - 0, - 0, - 0, - 27, - 240, - 1, - 0, - 0, - 0, - 29, - 242, - 1, - 0, - 0, - 0, - 31, - 244, - 1, - 0, - 0, - 0, - 33, - 246, - 1, - 0, - 0, - 0, - 35, - 248, - 1, - 0, - 0, - 0, - 37, - 250, - 1, - 0, - 0, - 0, - 39, - 252, - 1, - 0, - 0, - 0, - 41, - 254, - 1, - 0, - 0, - 0, - 43, - 256, - 1, - 0, - 0, - 0, - 45, - 258, - 1, - 0, - 0, - 0, - 47, - 260, - 1, - 0, - 0, - 0, - 49, - 262, - 1, - 0, - 0, - 0, - 51, - 264, - 1, - 0, - 0, - 0, - 53, - 266, - 1, - 0, - 0, - 0, - 55, - 268, - 1, - 0, - 0, - 0, - 57, - 270, - 1, - 0, - 0, - 0, - 59, - 272, - 1, - 0, - 0, - 0, - 61, - 282, - 1, - 0, - 0, - 0, - 63, - 284, - 1, - 0, - 0, - 0, - 65, - 287, - 1, - 0, - 0, - 0, - 67, - 292, - 1, - 0, - 0, - 0, - 69, - 297, - 1, - 0, - 0, - 0, - 71, - 305, - 1, - 0, - 0, - 0, - 73, - 308, - 1, - 0, - 0, - 0, - 75, - 312, - 1, - 0, - 0, - 0, - 77, - 316, - 1, - 0, - 0, - 0, - 79, - 320, - 1, - 0, - 0, - 0, - 81, - 325, - 1, - 0, - 0, - 0, - 83, - 330, - 1, - 0, - 0, - 0, - 85, - 337, - 1, - 0, - 0, - 0, - 87, - 344, - 1, - 0, - 0, - 0, - 89, - 354, - 1, - 0, - 0, - 0, - 91, - 367, - 1, - 0, - 0, - 0, - 93, - 372, - 1, - 0, - 0, - 0, - 95, - 377, - 1, - 0, - 0, - 0, - 97, - 391, - 1, - 0, - 0, - 0, - 99, - 404, - 1, - 0, - 0, - 0, - 101, - 409, - 1, - 0, - 0, - 0, - 103, - 417, - 1, - 0, - 0, - 0, - 105, - 437, - 1, - 0, - 0, - 0, - 107, - 460, - 1, - 0, - 0, - 0, - 109, - 470, - 1, - 0, - 0, - 0, - 111, - 478, - 1, - 0, - 0, - 0, - 113, - 490, - 1, - 0, - 0, - 0, - 115, - 497, - 1, - 0, - 0, - 0, - 117, - 505, - 1, - 0, - 0, - 0, - 119, - 510, - 1, - 0, - 0, - 0, - 121, - 514, - 1, - 0, - 0, - 0, - 123, - 518, - 1, - 0, - 0, - 0, - 125, - 521, - 1, - 0, - 0, - 0, - 127, - 526, - 1, - 0, - 0, - 0, - 129, - 530, - 1, - 0, - 0, - 0, - 131, - 535, - 1, - 0, - 0, - 0, - 133, - 538, - 1, - 0, - 0, - 0, - 135, - 543, - 1, - 0, - 0, - 0, - 137, - 549, - 1, - 0, - 0, - 0, - 139, - 554, - 1, - 0, - 0, - 0, - 141, - 558, - 1, - 0, - 0, - 0, - 143, - 562, - 1, - 0, - 0, - 0, - 145, - 568, - 1, - 0, - 0, - 0, - 147, - 574, - 1, - 0, - 0, - 0, - 149, - 580, - 1, - 0, - 0, - 0, - 151, - 585, - 1, - 0, - 0, - 0, - 153, - 588, - 1, - 0, - 0, - 0, - 155, - 595, - 1, - 0, - 0, - 0, - 157, - 597, - 1, - 0, - 0, - 0, - 159, - 599, - 1, - 0, - 0, - 0, - 161, - 601, - 1, - 0, - 0, - 0, - 163, - 603, - 1, - 0, - 0, - 0, - 165, - 605, - 1, - 0, - 0, - 0, - 167, - 607, - 1, - 0, - 0, - 0, - 169, - 609, - 1, - 0, - 0, - 0, - 171, - 611, - 1, - 0, - 0, - 0, - 173, - 613, - 1, - 0, - 0, - 0, - 175, - 615, - 1, - 0, - 0, - 0, - 177, - 617, - 1, - 0, - 0, - 0, - 179, - 180, - 5, - 47, - 0, - 0, - 180, - 181, - 5, - 47, - 0, - 0, - 181, - 185, - 1, - 0, - 0, - 0, - 182, - 184, - 8, - 0, - 0, - 0, - 183, - 182, - 1, - 0, - 0, - 0, - 184, - 187, - 1, - 0, - 0, - 0, - 185, - 183, - 1, - 0, - 0, - 0, - 185, - 186, - 1, - 0, - 0, - 0, - 186, - 188, - 1, - 0, - 0, - 0, - 187, - 185, - 1, - 0, - 0, - 0, - 188, - 189, - 6, - 0, - 0, - 0, - 189, - 2, - 1, - 0, - 0, - 0, - 190, - 191, - 5, - 47, - 0, - 0, - 191, - 192, - 5, - 42, - 0, - 0, - 192, - 200, - 1, - 0, - 0, - 0, - 193, - 201, - 8, - 1, - 0, - 0, - 194, - 196, - 5, - 42, - 0, - 0, - 195, - 194, - 1, - 0, - 0, - 0, - 196, - 197, - 1, - 0, - 0, - 0, - 197, - 195, - 1, - 0, - 0, - 0, - 197, - 198, - 1, - 0, - 0, - 0, - 198, - 199, - 1, - 0, - 0, - 0, - 199, - 201, - 8, - 2, - 0, - 0, - 200, - 193, - 1, - 0, - 0, - 0, - 200, - 195, - 1, - 0, - 0, - 0, - 201, - 205, - 1, - 0, - 0, - 0, - 202, - 204, - 5, - 42, - 0, - 0, - 203, - 202, - 1, - 0, - 0, - 0, - 204, - 207, - 1, - 0, - 0, - 0, - 205, - 203, - 1, - 0, - 0, - 0, - 205, - 206, - 1, - 0, - 0, - 0, - 206, - 208, - 1, - 0, - 0, - 0, - 207, - 205, - 1, - 0, - 0, - 0, - 208, - 209, - 5, - 42, - 0, - 0, - 209, - 210, - 5, - 47, - 0, - 0, - 210, - 211, - 1, - 0, - 0, - 0, - 211, - 212, - 6, - 1, - 0, - 0, - 212, - 4, - 1, - 0, - 0, - 0, - 213, - 215, - 7, - 3, - 0, - 0, - 214, - 213, - 1, - 0, - 0, - 0, - 215, - 216, - 1, - 0, - 0, - 0, - 216, - 214, - 1, - 0, - 0, - 0, - 216, - 217, - 1, - 0, - 0, - 0, - 217, - 218, - 1, - 0, - 0, - 0, - 218, - 219, - 6, - 2, - 0, - 0, - 219, - 6, - 1, - 0, - 0, - 0, - 220, - 221, - 7, - 4, - 0, - 0, - 221, - 8, - 1, - 0, - 0, - 0, - 222, - 223, - 7, - 5, - 0, - 0, - 223, - 10, - 1, - 0, - 0, - 0, - 224, - 225, - 7, - 6, - 0, - 0, - 225, - 12, - 1, - 0, - 0, - 0, - 226, - 227, - 7, - 7, - 0, - 0, - 227, - 14, - 1, - 0, - 0, - 0, - 228, - 229, - 7, - 8, - 0, - 0, - 229, - 16, - 1, - 0, - 0, - 0, - 230, - 231, - 7, - 9, - 0, - 0, - 231, - 18, - 1, - 0, - 0, - 0, - 232, - 233, - 7, - 10, - 0, - 0, - 233, - 20, - 1, - 0, - 0, - 0, - 234, - 235, - 7, - 11, - 0, - 0, - 235, - 22, - 1, - 0, - 0, - 0, - 236, - 237, - 7, - 12, - 0, - 0, - 237, - 24, - 1, - 0, - 0, - 0, - 238, - 239, - 7, - 13, - 0, - 0, - 239, - 26, - 1, - 0, - 0, - 0, - 240, - 241, - 7, - 14, - 0, - 0, - 241, - 28, - 1, - 0, - 0, - 0, - 242, - 243, - 7, - 15, - 0, - 0, - 243, - 30, - 1, - 0, - 0, - 0, - 244, - 245, - 7, - 16, - 0, - 0, - 245, - 32, - 1, - 0, - 0, - 0, - 246, - 247, - 7, - 17, - 0, - 0, - 247, - 34, - 1, - 0, - 0, - 0, - 248, - 249, - 7, - 18, - 0, - 0, - 249, - 36, - 1, - 0, - 0, - 0, - 250, - 251, - 7, - 19, - 0, - 0, - 251, - 38, - 1, - 0, - 0, - 0, - 252, - 253, - 7, - 20, - 0, - 0, - 253, - 40, - 1, - 0, - 0, - 0, - 254, - 255, - 7, - 21, - 0, - 0, - 255, - 42, - 1, - 0, - 0, - 0, - 256, - 257, - 7, - 22, - 0, - 0, - 257, - 44, - 1, - 0, - 0, - 0, - 258, - 259, - 7, - 23, - 0, - 0, - 259, - 46, - 1, - 0, - 0, - 0, - 260, - 261, - 7, - 24, - 0, - 0, - 261, - 48, - 1, - 0, - 0, - 0, - 262, - 263, - 7, - 25, - 0, - 0, - 263, - 50, - 1, - 0, - 0, - 0, - 264, - 265, - 7, - 26, - 0, - 0, - 265, - 52, - 1, - 0, - 0, - 0, - 266, - 267, - 7, - 27, - 0, - 0, - 267, - 54, - 1, - 0, - 0, - 0, - 268, - 269, - 7, - 28, - 0, - 0, - 269, - 56, - 1, - 0, - 0, - 0, - 270, - 271, - 7, - 29, - 0, - 0, - 271, - 58, - 1, - 0, - 0, - 0, - 272, - 273, - 7, - 30, - 0, - 0, - 273, - 60, - 1, - 0, - 0, - 0, - 274, - 283, - 5, - 48, - 0, - 0, - 275, - 279, - 7, - 31, - 0, - 0, - 276, - 278, - 7, - 30, - 0, - 0, - 277, - 276, - 1, - 0, - 0, - 0, - 278, - 281, - 1, - 0, - 0, - 0, - 279, - 277, - 1, - 0, - 0, - 0, - 279, - 280, - 1, - 0, - 0, - 0, - 280, - 283, - 1, - 0, - 0, - 0, - 281, - 279, - 1, - 0, - 0, - 0, - 282, - 274, - 1, - 0, - 0, - 0, - 282, - 275, - 1, - 0, - 0, - 0, - 283, - 62, - 1, - 0, - 0, - 0, - 284, - 285, - 3, - 23, - 11, - 0, - 285, - 286, - 3, - 17, - 8, - 0, - 286, - 64, - 1, - 0, - 0, - 0, - 287, - 288, - 3, - 45, - 22, - 0, - 288, - 289, - 3, - 21, - 10, - 0, - 289, - 290, - 3, - 15, - 7, - 0, - 290, - 291, - 3, - 33, - 16, - 0, - 291, - 66, - 1, - 0, - 0, - 0, - 292, - 293, - 3, - 15, - 7, - 0, - 293, - 294, - 3, - 29, - 14, - 0, - 294, - 295, - 3, - 43, - 21, - 0, - 295, - 296, - 3, - 15, - 7, - 0, - 296, - 68, - 1, - 0, - 0, - 0, - 297, - 298, - 3, - 9, - 4, - 0, - 298, - 299, - 3, - 35, - 17, - 0, - 299, - 300, - 3, - 35, - 17, - 0, - 300, - 301, - 3, - 29, - 14, - 0, - 301, - 302, - 3, - 15, - 7, - 0, - 302, - 303, - 3, - 7, - 3, - 0, - 303, - 304, - 3, - 33, - 16, - 0, - 304, - 70, - 1, - 0, - 0, - 0, - 305, - 306, - 3, - 23, - 11, - 0, - 306, - 307, - 5, - 56, - 0, - 0, - 307, - 72, - 1, - 0, - 0, - 0, - 308, - 309, - 3, - 23, - 11, - 0, - 309, - 310, - 5, - 49, - 0, - 0, - 310, - 311, - 5, - 54, - 0, - 0, - 311, - 74, - 1, - 0, - 0, - 0, - 312, - 313, - 3, - 23, - 11, - 0, - 313, - 314, - 5, - 51, - 0, - 0, - 314, - 315, - 5, - 50, - 0, - 0, - 315, - 76, - 1, - 0, - 0, - 0, - 316, - 317, - 3, - 23, - 11, - 0, - 317, - 318, - 5, - 54, - 0, - 0, - 318, - 319, - 5, - 52, - 0, - 0, - 319, - 78, - 1, - 0, - 0, - 0, - 320, - 321, - 3, - 17, - 8, - 0, - 321, - 322, - 3, - 37, - 18, - 0, - 322, - 323, - 5, - 51, - 0, - 0, - 323, - 324, - 5, - 50, - 0, - 0, - 324, - 80, - 1, - 0, - 0, - 0, - 325, - 326, - 3, - 17, - 8, - 0, - 326, - 327, - 3, - 37, - 18, - 0, - 327, - 328, - 5, - 54, - 0, - 0, - 328, - 329, - 5, - 52, - 0, - 0, - 329, - 82, - 1, - 0, - 0, - 0, - 330, - 331, - 3, - 43, - 21, - 0, - 331, - 332, - 3, - 45, - 22, - 0, - 332, - 333, - 3, - 41, - 20, - 0, - 333, - 334, - 3, - 23, - 11, - 0, - 334, - 335, - 3, - 33, - 16, - 0, - 335, - 336, - 3, - 19, - 9, - 0, - 336, - 84, - 1, - 0, - 0, - 0, - 337, - 338, - 3, - 9, - 4, - 0, - 338, - 339, - 3, - 23, - 11, - 0, - 339, - 340, - 3, - 33, - 16, - 0, - 340, - 341, - 3, - 7, - 3, - 0, - 341, - 342, - 3, - 41, - 20, - 0, - 342, - 343, - 3, - 55, - 27, - 0, - 343, - 86, - 1, - 0, - 0, - 0, - 344, - 345, - 3, - 45, - 22, - 0, - 345, - 346, - 3, - 23, - 11, - 0, - 346, - 347, - 3, - 31, - 15, - 0, - 347, - 348, - 3, - 15, - 7, - 0, - 348, - 349, - 3, - 43, - 21, - 0, - 349, - 350, - 3, - 45, - 22, - 0, - 350, - 351, - 3, - 7, - 3, - 0, - 351, - 352, - 3, - 31, - 15, - 0, - 352, - 353, - 3, - 37, - 18, - 0, - 353, - 88, - 1, - 0, - 0, - 0, - 354, - 355, - 3, - 45, - 22, - 0, - 355, - 356, - 3, - 23, - 11, - 0, - 356, - 357, - 3, - 31, - 15, - 0, - 357, - 358, - 3, - 15, - 7, - 0, - 358, - 359, - 3, - 43, - 21, - 0, - 359, - 360, - 3, - 45, - 22, - 0, - 360, - 361, - 3, - 7, - 3, - 0, - 361, - 362, - 3, - 31, - 15, - 0, - 362, - 363, - 3, - 37, - 18, - 0, - 363, - 364, - 5, - 95, - 0, - 0, - 364, - 365, - 3, - 45, - 22, - 0, - 365, - 366, - 3, - 57, - 28, - 0, - 366, - 90, - 1, - 0, - 0, - 0, - 367, - 368, - 3, - 13, - 6, - 0, - 368, - 369, - 3, - 7, - 3, - 0, - 369, - 370, - 3, - 45, - 22, - 0, - 370, - 371, - 3, - 15, - 7, - 0, - 371, - 92, - 1, - 0, - 0, - 0, - 372, - 373, - 3, - 45, - 22, - 0, - 373, - 374, - 3, - 23, - 11, - 0, - 374, - 375, - 3, - 31, - 15, - 0, - 375, - 376, - 3, - 15, - 7, - 0, - 376, - 94, - 1, - 0, - 0, - 0, - 377, - 378, - 3, - 23, - 11, - 0, - 378, - 379, - 3, - 33, - 16, - 0, - 379, - 380, - 3, - 45, - 22, - 0, - 380, - 381, - 3, - 15, - 7, - 0, - 381, - 382, - 3, - 41, - 20, - 0, - 382, - 383, - 3, - 49, - 24, - 0, - 383, - 384, - 3, - 7, - 3, - 0, - 384, - 385, - 3, - 29, - 14, - 0, - 385, - 386, - 5, - 95, - 0, - 0, - 386, - 387, - 3, - 55, - 27, - 0, - 387, - 388, - 3, - 15, - 7, - 0, - 388, - 389, - 3, - 7, - 3, - 0, - 389, - 390, - 3, - 41, - 20, - 0, - 390, - 96, - 1, - 0, - 0, - 0, - 391, - 392, - 3, - 23, - 11, - 0, - 392, - 393, - 3, - 33, - 16, - 0, - 393, - 394, - 3, - 45, - 22, - 0, - 394, - 395, - 3, - 15, - 7, - 0, - 395, - 396, - 3, - 41, - 20, - 0, - 396, - 397, - 3, - 49, - 24, - 0, - 397, - 398, - 3, - 7, - 3, - 0, - 398, - 399, - 3, - 29, - 14, - 0, - 399, - 400, - 5, - 95, - 0, - 0, - 400, - 401, - 3, - 13, - 6, - 0, - 401, - 402, - 3, - 7, - 3, - 0, - 402, - 403, - 3, - 55, - 27, - 0, - 403, - 98, - 1, - 0, - 0, - 0, - 404, - 405, - 3, - 47, - 23, - 0, - 405, - 406, - 3, - 47, - 23, - 0, - 406, - 407, - 3, - 23, - 11, - 0, - 407, - 408, - 3, - 13, - 6, - 0, - 408, - 100, - 1, - 0, - 0, - 0, - 409, - 410, - 3, - 13, - 6, - 0, - 410, - 411, - 3, - 15, - 7, - 0, - 411, - 412, - 3, - 11, - 5, - 0, - 412, - 413, - 3, - 23, - 11, - 0, - 413, - 414, - 3, - 31, - 15, - 0, - 414, - 415, - 3, - 7, - 3, - 0, - 415, - 416, - 3, - 29, - 14, - 0, - 416, - 102, - 1, - 0, - 0, - 0, - 417, - 418, - 3, - 37, - 18, - 0, - 418, - 419, - 3, - 41, - 20, - 0, - 419, - 420, - 3, - 15, - 7, - 0, - 420, - 421, - 3, - 11, - 5, - 0, - 421, - 422, - 3, - 23, - 11, - 0, - 422, - 423, - 3, - 43, - 21, - 0, - 423, - 424, - 3, - 23, - 11, - 0, - 424, - 425, - 3, - 35, - 17, - 0, - 425, - 426, - 3, - 33, - 16, - 0, - 426, - 427, - 5, - 95, - 0, - 0, - 427, - 428, - 3, - 45, - 22, - 0, - 428, - 429, - 3, - 23, - 11, - 0, - 429, - 430, - 3, - 31, - 15, - 0, - 430, - 431, - 3, - 15, - 7, - 0, - 431, - 432, - 3, - 43, - 21, - 0, - 432, - 433, - 3, - 45, - 22, - 0, - 433, - 434, - 3, - 7, - 3, - 0, - 434, - 435, - 3, - 31, - 15, - 0, - 435, - 436, - 3, - 37, - 18, - 0, - 436, - 104, - 1, - 0, - 0, - 0, - 437, - 438, - 3, - 37, - 18, - 0, - 438, - 439, - 3, - 41, - 20, - 0, - 439, - 440, - 3, - 15, - 7, - 0, - 440, - 441, - 3, - 11, - 5, - 0, - 441, - 442, - 3, - 23, - 11, - 0, - 442, - 443, - 3, - 43, - 21, - 0, - 443, - 444, - 3, - 23, - 11, - 0, - 444, - 445, - 3, - 35, - 17, - 0, - 445, - 446, - 3, - 33, - 16, - 0, - 446, - 447, - 5, - 95, - 0, - 0, - 447, - 448, - 3, - 45, - 22, - 0, - 448, - 449, - 3, - 23, - 11, - 0, - 449, - 450, - 3, - 31, - 15, - 0, - 450, - 451, - 3, - 15, - 7, - 0, - 451, - 452, - 3, - 43, - 21, - 0, - 452, - 453, - 3, - 45, - 22, - 0, - 453, - 454, - 3, - 7, - 3, - 0, - 454, - 455, - 3, - 31, - 15, - 0, - 455, - 456, - 3, - 37, - 18, - 0, - 456, - 457, - 5, - 95, - 0, - 0, - 457, - 458, - 3, - 45, - 22, - 0, - 458, - 459, - 3, - 57, - 28, - 0, - 459, - 106, - 1, - 0, - 0, - 0, - 460, - 461, - 3, - 17, - 8, - 0, - 461, - 462, - 3, - 23, - 11, - 0, - 462, - 463, - 3, - 53, - 26, - 0, - 463, - 464, - 3, - 15, - 7, - 0, - 464, - 465, - 3, - 13, - 6, - 0, - 465, - 466, - 3, - 11, - 5, - 0, - 466, - 467, - 3, - 21, - 10, - 0, - 467, - 468, - 3, - 7, - 3, - 0, - 468, - 469, - 3, - 41, - 20, - 0, - 469, - 108, - 1, - 0, - 0, - 0, - 470, - 471, - 3, - 49, - 24, - 0, - 471, - 472, - 3, - 7, - 3, - 0, - 472, - 473, - 3, - 41, - 20, - 0, - 473, - 474, - 3, - 11, - 5, - 0, - 474, - 475, - 3, - 21, - 10, - 0, - 475, - 476, - 3, - 7, - 3, - 0, - 476, - 477, - 3, - 41, - 20, - 0, - 477, - 110, - 1, - 0, - 0, - 0, - 478, - 479, - 3, - 17, - 8, - 0, - 479, - 480, - 3, - 23, - 11, - 0, - 480, - 481, - 3, - 53, - 26, - 0, - 481, - 482, - 3, - 15, - 7, - 0, - 482, - 483, - 3, - 13, - 6, - 0, - 483, - 484, - 3, - 9, - 4, - 0, - 484, - 485, - 3, - 23, - 11, - 0, - 485, - 486, - 3, - 33, - 16, - 0, - 486, - 487, - 3, - 7, - 3, - 0, - 487, - 488, - 3, - 41, - 20, - 0, - 488, - 489, - 3, - 55, - 27, - 0, - 489, - 112, - 1, - 0, - 0, - 0, - 490, - 491, - 3, - 43, - 21, - 0, - 491, - 492, - 3, - 45, - 22, - 0, - 492, - 493, - 3, - 41, - 20, - 0, - 493, - 494, - 3, - 47, - 23, - 0, - 494, - 495, - 3, - 11, - 5, - 0, - 495, - 496, - 3, - 45, - 22, - 0, - 496, - 114, - 1, - 0, - 0, - 0, - 497, - 498, - 3, - 33, - 16, - 0, - 498, - 499, - 3, - 43, - 21, - 0, - 499, - 500, - 3, - 45, - 22, - 0, - 500, - 501, - 3, - 41, - 20, - 0, - 501, - 502, - 3, - 47, - 23, - 0, - 502, - 503, - 3, - 11, - 5, - 0, - 503, - 504, - 3, - 45, - 22, - 0, - 504, - 116, - 1, - 0, - 0, - 0, - 505, - 506, - 3, - 29, - 14, - 0, - 506, - 507, - 3, - 23, - 11, - 0, - 507, - 508, - 3, - 43, - 21, - 0, - 508, - 509, - 3, - 45, - 22, - 0, - 509, - 118, - 1, - 0, - 0, - 0, - 510, - 511, - 3, - 31, - 15, - 0, - 511, - 512, - 3, - 7, - 3, - 0, - 512, - 513, - 3, - 37, - 18, - 0, - 513, - 120, - 1, - 0, - 0, - 0, - 514, - 515, - 3, - 7, - 3, - 0, - 515, - 516, - 3, - 33, - 16, - 0, - 516, - 517, - 3, - 55, - 27, - 0, - 517, - 122, - 1, - 0, - 0, - 0, - 518, - 519, - 3, - 47, - 23, - 0, - 519, - 520, - 5, - 33, - 0, - 0, - 520, - 124, - 1, - 0, - 0, - 0, - 521, - 522, - 3, - 9, - 4, - 0, - 522, - 523, - 3, - 35, - 17, - 0, - 523, - 524, - 3, - 35, - 17, - 0, - 524, - 525, - 3, - 29, - 14, - 0, - 525, - 126, - 1, - 0, - 0, - 0, - 526, - 527, - 3, - 43, - 21, - 0, - 527, - 528, - 3, - 45, - 22, - 0, - 528, - 529, - 3, - 41, - 20, - 0, - 529, - 128, - 1, - 0, - 0, - 0, - 530, - 531, - 3, - 49, - 24, - 0, - 531, - 532, - 3, - 9, - 4, - 0, - 532, - 533, - 3, - 23, - 11, - 0, - 533, - 534, - 3, - 33, - 16, - 0, - 534, - 130, - 1, - 0, - 0, - 0, - 535, - 536, - 3, - 45, - 22, - 0, - 536, - 537, - 3, - 43, - 21, - 0, - 537, - 132, - 1, - 0, - 0, - 0, - 538, - 539, - 3, - 45, - 22, - 0, - 539, - 540, - 3, - 43, - 21, - 0, - 540, - 541, - 3, - 45, - 22, - 0, - 541, - 542, - 3, - 57, - 28, - 0, - 542, - 134, - 1, - 0, - 0, - 0, - 543, - 544, - 3, - 23, - 11, - 0, - 544, - 545, - 3, - 55, - 27, - 0, - 545, - 546, - 3, - 15, - 7, - 0, - 546, - 547, - 3, - 7, - 3, - 0, - 547, - 548, - 3, - 41, - 20, - 0, - 548, - 136, - 1, - 0, - 0, - 0, - 549, - 550, - 3, - 23, - 11, - 0, - 550, - 551, - 3, - 13, - 6, - 0, - 551, - 552, - 3, - 7, - 3, - 0, - 552, - 553, - 3, - 55, - 27, - 0, - 553, - 138, - 1, - 0, - 0, - 0, - 554, - 555, - 3, - 13, - 6, - 0, - 555, - 556, - 3, - 15, - 7, - 0, - 556, - 557, - 3, - 11, - 5, - 0, - 557, - 140, - 1, - 0, - 0, - 0, - 558, - 559, - 3, - 37, - 18, - 0, - 559, - 560, - 3, - 45, - 22, - 0, - 560, - 561, - 3, - 43, - 21, - 0, - 561, - 142, - 1, - 0, - 0, - 0, - 562, - 563, - 3, - 37, - 18, - 0, - 563, - 564, - 3, - 45, - 22, - 0, - 564, - 565, - 3, - 43, - 21, - 0, - 565, - 566, - 3, - 45, - 22, - 0, - 566, - 567, - 3, - 57, - 28, - 0, - 567, - 144, - 1, - 0, - 0, - 0, - 568, - 569, - 3, - 17, - 8, - 0, - 569, - 570, - 3, - 11, - 5, - 0, - 570, - 571, - 3, - 21, - 10, - 0, - 571, - 572, - 3, - 7, - 3, - 0, - 572, - 573, - 3, - 41, - 20, - 0, - 573, - 146, - 1, - 0, - 0, - 0, - 574, - 575, - 3, - 49, - 24, - 0, - 575, - 576, - 3, - 11, - 5, - 0, - 576, - 577, - 3, - 21, - 10, - 0, - 577, - 578, - 3, - 7, - 3, - 0, - 578, - 579, - 3, - 41, - 20, - 0, - 579, - 148, - 1, - 0, - 0, - 0, - 580, - 581, - 3, - 17, - 8, - 0, - 581, - 582, - 3, - 9, - 4, - 0, - 582, - 583, - 3, - 23, - 11, - 0, - 583, - 584, - 3, - 33, - 16, - 0, - 584, - 150, - 1, - 0, - 0, - 0, - 585, - 586, - 5, - 58, - 0, - 0, - 586, - 587, - 5, - 58, - 0, - 0, - 587, - 152, - 1, - 0, - 0, - 0, - 588, - 592, - 7, - 32, - 0, - 0, - 589, - 591, - 7, - 33, - 0, - 0, - 590, - 589, - 1, - 0, - 0, - 0, - 591, - 594, - 1, - 0, - 0, - 0, - 592, - 590, - 1, - 0, - 0, - 0, - 592, - 593, - 1, - 0, - 0, - 0, - 593, - 154, - 1, - 0, - 0, - 0, - 594, - 592, - 1, - 0, - 0, - 0, - 595, - 596, - 5, - 60, - 0, - 0, - 596, - 156, - 1, - 0, - 0, - 0, - 597, - 598, - 5, - 62, - 0, - 0, - 598, - 158, - 1, - 0, - 0, - 0, - 599, - 600, - 5, - 40, - 0, - 0, - 600, - 160, - 1, - 0, - 0, - 0, - 601, - 602, - 5, - 41, - 0, - 0, - 602, - 162, - 1, - 0, - 0, - 0, - 603, - 604, - 5, - 91, - 0, - 0, - 604, - 164, - 1, - 0, - 0, - 0, - 605, - 606, - 5, - 93, - 0, - 0, - 606, - 166, - 1, - 0, - 0, - 0, - 607, - 608, - 5, - 44, - 0, - 0, - 608, - 168, - 1, - 0, - 0, - 0, - 609, - 610, - 5, - 61, - 0, - 0, - 610, - 170, - 1, - 0, - 0, - 0, - 611, - 612, - 5, - 58, - 0, - 0, - 612, - 172, - 1, - 0, - 0, - 0, - 613, - 614, - 5, - 63, - 0, - 0, - 614, - 174, - 1, - 0, - 0, - 0, - 615, - 616, - 5, - 35, - 0, - 0, - 616, - 176, - 1, - 0, - 0, - 0, - 617, - 618, - 5, - 46, - 0, - 0, - 618, - 178, - 1, - 0, - 0, - 0, - 9, - 0, - 185, - 197, - 200, - 205, - 216, - 279, - 282, - 592, - 1, - 0, - 1, - 0, + 4,0,62,630,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, + 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, + 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, + 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, + 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, + 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, + 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, + 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, + 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, + 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, + 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, + 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, + 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, + 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,1,0,1,0,1,0, + 1,0,5,0,186,8,0,10,0,12,0,189,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,4, + 1,198,8,1,11,1,12,1,199,1,1,3,1,203,8,1,1,1,5,1,206,8,1,10,1,12, + 1,209,9,1,1,1,1,1,1,1,1,1,1,1,1,2,4,2,217,8,2,11,2,12,2,218,1,2, + 1,2,1,3,1,3,1,4,1,4,1,5,1,5,1,6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10, + 1,10,1,11,1,11,1,12,1,12,1,13,1,13,1,14,1,14,1,15,1,15,1,16,1,16, + 1,17,1,17,1,18,1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1,23, + 1,23,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29, + 1,30,1,30,1,30,5,30,280,8,30,10,30,12,30,283,9,30,3,30,285,8,30, + 1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,33, + 1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,36,1,36, + 1,36,1,36,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,39,1,39,1,39, + 1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41, + 1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43, + 1,43,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, + 1,44,1,44,1,44,1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46, + 1,46,1,46,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47, + 1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48, + 1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50, + 1,50,1,50,1,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51, + 1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, + 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53, + 1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,55, + 1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,56,1,56, + 1,56,1,56,1,56,1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57, + 1,58,1,58,1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60, + 1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,63, + 1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,65, + 1,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68, + 1,68,1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,71,1,71,1,71, + 1,71,1,72,1,72,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1,73,1,73, + 1,74,1,74,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,76,1,76, + 1,76,1,77,1,77,5,77,602,8,77,10,77,12,77,605,9,77,1,78,1,78,1,79, + 1,79,1,80,1,80,1,81,1,81,1,82,1,82,1,83,1,83,1,84,1,84,1,85,1,85, + 1,86,1,86,1,87,1,87,1,88,1,88,1,89,1,89,0,0,90,1,1,3,2,5,3,7,0,9, + 0,11,0,13,0,15,0,17,0,19,0,21,0,23,0,25,0,27,0,29,0,31,0,33,0,35, + 0,37,0,39,0,41,0,43,0,45,0,47,0,49,0,51,0,53,0,55,0,57,0,59,0,61, + 0,63,4,65,5,67,6,69,7,71,8,73,9,75,10,77,11,79,12,81,13,83,14,85, + 15,87,16,89,17,91,18,93,19,95,20,97,21,99,22,101,23,103,24,105,25, + 107,26,109,27,111,28,113,29,115,30,117,31,119,32,121,33,123,34,125, + 35,127,36,129,37,131,38,133,39,135,40,137,41,139,42,141,43,143,44, + 145,45,147,46,149,47,151,48,153,49,155,50,157,51,159,52,161,53,163, + 54,165,55,167,56,169,57,171,58,173,59,175,60,177,61,179,62,1,0,34, + 2,0,10,10,13,13,1,0,42,42,2,0,42,42,47,47,3,0,9,10,13,13,32,32,2, + 0,65,65,97,97,2,0,66,66,98,98,2,0,67,67,99,99,2,0,68,68,100,100, + 2,0,69,69,101,101,2,0,70,70,102,102,2,0,71,71,103,103,2,0,72,72, + 104,104,2,0,73,73,105,105,2,0,74,74,106,106,2,0,75,75,107,107,2, + 0,76,76,108,108,2,0,77,77,109,109,2,0,78,78,110,110,2,0,79,79,111, + 111,2,0,80,80,112,112,2,0,81,81,113,113,2,0,82,82,114,114,2,0,83, + 83,115,115,2,0,84,84,116,116,2,0,85,85,117,117,2,0,86,86,118,118, + 2,0,87,87,119,119,2,0,88,88,120,120,2,0,89,89,121,121,2,0,90,90, + 122,122,1,0,48,57,1,0,49,57,3,0,65,90,95,95,97,122,4,0,48,57,65, + 90,95,95,97,122,609,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,63,1,0, + 0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0, + 0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0, + 0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0, + 0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1, + 0,0,0,0,105,1,0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0, + 113,1,0,0,0,0,115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0, + 0,0,0,123,1,0,0,0,0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131, + 1,0,0,0,0,133,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0, + 0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1, + 0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157,1,0,0,0,0, + 159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0,167,1,0, + 0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0,177, + 1,0,0,0,0,179,1,0,0,0,1,181,1,0,0,0,3,192,1,0,0,0,5,216,1,0,0,0, + 7,222,1,0,0,0,9,224,1,0,0,0,11,226,1,0,0,0,13,228,1,0,0,0,15,230, + 1,0,0,0,17,232,1,0,0,0,19,234,1,0,0,0,21,236,1,0,0,0,23,238,1,0, + 0,0,25,240,1,0,0,0,27,242,1,0,0,0,29,244,1,0,0,0,31,246,1,0,0,0, + 33,248,1,0,0,0,35,250,1,0,0,0,37,252,1,0,0,0,39,254,1,0,0,0,41,256, + 1,0,0,0,43,258,1,0,0,0,45,260,1,0,0,0,47,262,1,0,0,0,49,264,1,0, + 0,0,51,266,1,0,0,0,53,268,1,0,0,0,55,270,1,0,0,0,57,272,1,0,0,0, + 59,274,1,0,0,0,61,284,1,0,0,0,63,286,1,0,0,0,65,289,1,0,0,0,67,294, + 1,0,0,0,69,299,1,0,0,0,71,307,1,0,0,0,73,310,1,0,0,0,75,314,1,0, + 0,0,77,318,1,0,0,0,79,322,1,0,0,0,81,327,1,0,0,0,83,332,1,0,0,0, + 85,339,1,0,0,0,87,346,1,0,0,0,89,356,1,0,0,0,91,369,1,0,0,0,93,374, + 1,0,0,0,95,379,1,0,0,0,97,393,1,0,0,0,99,406,1,0,0,0,101,411,1,0, + 0,0,103,419,1,0,0,0,105,439,1,0,0,0,107,462,1,0,0,0,109,472,1,0, + 0,0,111,480,1,0,0,0,113,492,1,0,0,0,115,499,1,0,0,0,117,507,1,0, + 0,0,119,512,1,0,0,0,121,516,1,0,0,0,123,520,1,0,0,0,125,523,1,0, + 0,0,127,532,1,0,0,0,129,537,1,0,0,0,131,541,1,0,0,0,133,546,1,0, + 0,0,135,549,1,0,0,0,137,554,1,0,0,0,139,560,1,0,0,0,141,565,1,0, + 0,0,143,569,1,0,0,0,145,573,1,0,0,0,147,579,1,0,0,0,149,585,1,0, + 0,0,151,591,1,0,0,0,153,596,1,0,0,0,155,599,1,0,0,0,157,606,1,0, + 0,0,159,608,1,0,0,0,161,610,1,0,0,0,163,612,1,0,0,0,165,614,1,0, + 0,0,167,616,1,0,0,0,169,618,1,0,0,0,171,620,1,0,0,0,173,622,1,0, + 0,0,175,624,1,0,0,0,177,626,1,0,0,0,179,628,1,0,0,0,181,182,5,47, + 0,0,182,183,5,47,0,0,183,187,1,0,0,0,184,186,8,0,0,0,185,184,1,0, + 0,0,186,189,1,0,0,0,187,185,1,0,0,0,187,188,1,0,0,0,188,190,1,0, + 0,0,189,187,1,0,0,0,190,191,6,0,0,0,191,2,1,0,0,0,192,193,5,47,0, + 0,193,194,5,42,0,0,194,202,1,0,0,0,195,203,8,1,0,0,196,198,5,42, + 0,0,197,196,1,0,0,0,198,199,1,0,0,0,199,197,1,0,0,0,199,200,1,0, + 0,0,200,201,1,0,0,0,201,203,8,2,0,0,202,195,1,0,0,0,202,197,1,0, + 0,0,203,207,1,0,0,0,204,206,5,42,0,0,205,204,1,0,0,0,206,209,1,0, + 0,0,207,205,1,0,0,0,207,208,1,0,0,0,208,210,1,0,0,0,209,207,1,0, + 0,0,210,211,5,42,0,0,211,212,5,47,0,0,212,213,1,0,0,0,213,214,6, + 1,0,0,214,4,1,0,0,0,215,217,7,3,0,0,216,215,1,0,0,0,217,218,1,0, + 0,0,218,216,1,0,0,0,218,219,1,0,0,0,219,220,1,0,0,0,220,221,6,2, + 0,0,221,6,1,0,0,0,222,223,7,4,0,0,223,8,1,0,0,0,224,225,7,5,0,0, + 225,10,1,0,0,0,226,227,7,6,0,0,227,12,1,0,0,0,228,229,7,7,0,0,229, + 14,1,0,0,0,230,231,7,8,0,0,231,16,1,0,0,0,232,233,7,9,0,0,233,18, + 1,0,0,0,234,235,7,10,0,0,235,20,1,0,0,0,236,237,7,11,0,0,237,22, + 1,0,0,0,238,239,7,12,0,0,239,24,1,0,0,0,240,241,7,13,0,0,241,26, + 1,0,0,0,242,243,7,14,0,0,243,28,1,0,0,0,244,245,7,15,0,0,245,30, + 1,0,0,0,246,247,7,16,0,0,247,32,1,0,0,0,248,249,7,17,0,0,249,34, + 1,0,0,0,250,251,7,18,0,0,251,36,1,0,0,0,252,253,7,19,0,0,253,38, + 1,0,0,0,254,255,7,20,0,0,255,40,1,0,0,0,256,257,7,21,0,0,257,42, + 1,0,0,0,258,259,7,22,0,0,259,44,1,0,0,0,260,261,7,23,0,0,261,46, + 1,0,0,0,262,263,7,24,0,0,263,48,1,0,0,0,264,265,7,25,0,0,265,50, + 1,0,0,0,266,267,7,26,0,0,267,52,1,0,0,0,268,269,7,27,0,0,269,54, + 1,0,0,0,270,271,7,28,0,0,271,56,1,0,0,0,272,273,7,29,0,0,273,58, + 1,0,0,0,274,275,7,30,0,0,275,60,1,0,0,0,276,285,5,48,0,0,277,281, + 7,31,0,0,278,280,7,30,0,0,279,278,1,0,0,0,280,283,1,0,0,0,281,279, + 1,0,0,0,281,282,1,0,0,0,282,285,1,0,0,0,283,281,1,0,0,0,284,276, + 1,0,0,0,284,277,1,0,0,0,285,62,1,0,0,0,286,287,3,23,11,0,287,288, + 3,17,8,0,288,64,1,0,0,0,289,290,3,45,22,0,290,291,3,21,10,0,291, + 292,3,15,7,0,292,293,3,33,16,0,293,66,1,0,0,0,294,295,3,15,7,0,295, + 296,3,29,14,0,296,297,3,43,21,0,297,298,3,15,7,0,298,68,1,0,0,0, + 299,300,3,9,4,0,300,301,3,35,17,0,301,302,3,35,17,0,302,303,3,29, + 14,0,303,304,3,15,7,0,304,305,3,7,3,0,305,306,3,33,16,0,306,70,1, + 0,0,0,307,308,3,23,11,0,308,309,5,56,0,0,309,72,1,0,0,0,310,311, + 3,23,11,0,311,312,5,49,0,0,312,313,5,54,0,0,313,74,1,0,0,0,314,315, + 3,23,11,0,315,316,5,51,0,0,316,317,5,50,0,0,317,76,1,0,0,0,318,319, + 3,23,11,0,319,320,5,54,0,0,320,321,5,52,0,0,321,78,1,0,0,0,322,323, + 3,17,8,0,323,324,3,37,18,0,324,325,5,51,0,0,325,326,5,50,0,0,326, + 80,1,0,0,0,327,328,3,17,8,0,328,329,3,37,18,0,329,330,5,54,0,0,330, + 331,5,52,0,0,331,82,1,0,0,0,332,333,3,43,21,0,333,334,3,45,22,0, + 334,335,3,41,20,0,335,336,3,23,11,0,336,337,3,33,16,0,337,338,3, + 19,9,0,338,84,1,0,0,0,339,340,3,9,4,0,340,341,3,23,11,0,341,342, + 3,33,16,0,342,343,3,7,3,0,343,344,3,41,20,0,344,345,3,55,27,0,345, + 86,1,0,0,0,346,347,3,45,22,0,347,348,3,23,11,0,348,349,3,31,15,0, + 349,350,3,15,7,0,350,351,3,43,21,0,351,352,3,45,22,0,352,353,3,7, + 3,0,353,354,3,31,15,0,354,355,3,37,18,0,355,88,1,0,0,0,356,357,3, + 45,22,0,357,358,3,23,11,0,358,359,3,31,15,0,359,360,3,15,7,0,360, + 361,3,43,21,0,361,362,3,45,22,0,362,363,3,7,3,0,363,364,3,31,15, + 0,364,365,3,37,18,0,365,366,5,95,0,0,366,367,3,45,22,0,367,368,3, + 57,28,0,368,90,1,0,0,0,369,370,3,13,6,0,370,371,3,7,3,0,371,372, + 3,45,22,0,372,373,3,15,7,0,373,92,1,0,0,0,374,375,3,45,22,0,375, + 376,3,23,11,0,376,377,3,31,15,0,377,378,3,15,7,0,378,94,1,0,0,0, + 379,380,3,23,11,0,380,381,3,33,16,0,381,382,3,45,22,0,382,383,3, + 15,7,0,383,384,3,41,20,0,384,385,3,49,24,0,385,386,3,7,3,0,386,387, + 3,29,14,0,387,388,5,95,0,0,388,389,3,55,27,0,389,390,3,15,7,0,390, + 391,3,7,3,0,391,392,3,41,20,0,392,96,1,0,0,0,393,394,3,23,11,0,394, + 395,3,33,16,0,395,396,3,45,22,0,396,397,3,15,7,0,397,398,3,41,20, + 0,398,399,3,49,24,0,399,400,3,7,3,0,400,401,3,29,14,0,401,402,5, + 95,0,0,402,403,3,13,6,0,403,404,3,7,3,0,404,405,3,55,27,0,405,98, + 1,0,0,0,406,407,3,47,23,0,407,408,3,47,23,0,408,409,3,23,11,0,409, + 410,3,13,6,0,410,100,1,0,0,0,411,412,3,13,6,0,412,413,3,15,7,0,413, + 414,3,11,5,0,414,415,3,23,11,0,415,416,3,31,15,0,416,417,3,7,3,0, + 417,418,3,29,14,0,418,102,1,0,0,0,419,420,3,37,18,0,420,421,3,41, + 20,0,421,422,3,15,7,0,422,423,3,11,5,0,423,424,3,23,11,0,424,425, + 3,43,21,0,425,426,3,23,11,0,426,427,3,35,17,0,427,428,3,33,16,0, + 428,429,5,95,0,0,429,430,3,45,22,0,430,431,3,23,11,0,431,432,3,31, + 15,0,432,433,3,15,7,0,433,434,3,43,21,0,434,435,3,45,22,0,435,436, + 3,7,3,0,436,437,3,31,15,0,437,438,3,37,18,0,438,104,1,0,0,0,439, + 440,3,37,18,0,440,441,3,41,20,0,441,442,3,15,7,0,442,443,3,11,5, + 0,443,444,3,23,11,0,444,445,3,43,21,0,445,446,3,23,11,0,446,447, + 3,35,17,0,447,448,3,33,16,0,448,449,5,95,0,0,449,450,3,45,22,0,450, + 451,3,23,11,0,451,452,3,31,15,0,452,453,3,15,7,0,453,454,3,43,21, + 0,454,455,3,45,22,0,455,456,3,7,3,0,456,457,3,31,15,0,457,458,3, + 37,18,0,458,459,5,95,0,0,459,460,3,45,22,0,460,461,3,57,28,0,461, + 106,1,0,0,0,462,463,3,17,8,0,463,464,3,23,11,0,464,465,3,53,26,0, + 465,466,3,15,7,0,466,467,3,13,6,0,467,468,3,11,5,0,468,469,3,21, + 10,0,469,470,3,7,3,0,470,471,3,41,20,0,471,108,1,0,0,0,472,473,3, + 49,24,0,473,474,3,7,3,0,474,475,3,41,20,0,475,476,3,11,5,0,476,477, + 3,21,10,0,477,478,3,7,3,0,478,479,3,41,20,0,479,110,1,0,0,0,480, + 481,3,17,8,0,481,482,3,23,11,0,482,483,3,53,26,0,483,484,3,15,7, + 0,484,485,3,13,6,0,485,486,3,9,4,0,486,487,3,23,11,0,487,488,3,33, + 16,0,488,489,3,7,3,0,489,490,3,41,20,0,490,491,3,55,27,0,491,112, + 1,0,0,0,492,493,3,43,21,0,493,494,3,45,22,0,494,495,3,41,20,0,495, + 496,3,47,23,0,496,497,3,11,5,0,497,498,3,45,22,0,498,114,1,0,0,0, + 499,500,3,33,16,0,500,501,3,43,21,0,501,502,3,45,22,0,502,503,3, + 41,20,0,503,504,3,47,23,0,504,505,3,11,5,0,505,506,3,45,22,0,506, + 116,1,0,0,0,507,508,3,29,14,0,508,509,3,23,11,0,509,510,3,43,21, + 0,510,511,3,45,22,0,511,118,1,0,0,0,512,513,3,31,15,0,513,514,3, + 7,3,0,514,515,3,37,18,0,515,120,1,0,0,0,516,517,3,7,3,0,517,518, + 3,33,16,0,518,519,3,55,27,0,519,122,1,0,0,0,520,521,3,47,23,0,521, + 522,5,33,0,0,522,124,1,0,0,0,523,524,3,19,9,0,524,525,3,15,7,0,525, + 526,3,35,17,0,526,527,3,31,15,0,527,528,3,15,7,0,528,529,3,45,22, + 0,529,530,3,41,20,0,530,531,3,55,27,0,531,126,1,0,0,0,532,533,3, + 9,4,0,533,534,3,35,17,0,534,535,3,35,17,0,535,536,3,29,14,0,536, + 128,1,0,0,0,537,538,3,43,21,0,538,539,3,45,22,0,539,540,3,41,20, + 0,540,130,1,0,0,0,541,542,3,49,24,0,542,543,3,9,4,0,543,544,3,23, + 11,0,544,545,3,33,16,0,545,132,1,0,0,0,546,547,3,45,22,0,547,548, + 3,43,21,0,548,134,1,0,0,0,549,550,3,45,22,0,550,551,3,43,21,0,551, + 552,3,45,22,0,552,553,3,57,28,0,553,136,1,0,0,0,554,555,3,23,11, + 0,555,556,3,55,27,0,556,557,3,15,7,0,557,558,3,7,3,0,558,559,3,41, + 20,0,559,138,1,0,0,0,560,561,3,23,11,0,561,562,3,13,6,0,562,563, + 3,7,3,0,563,564,3,55,27,0,564,140,1,0,0,0,565,566,3,13,6,0,566,567, + 3,15,7,0,567,568,3,11,5,0,568,142,1,0,0,0,569,570,3,37,18,0,570, + 571,3,45,22,0,571,572,3,43,21,0,572,144,1,0,0,0,573,574,3,37,18, + 0,574,575,3,45,22,0,575,576,3,43,21,0,576,577,3,45,22,0,577,578, + 3,57,28,0,578,146,1,0,0,0,579,580,3,17,8,0,580,581,3,11,5,0,581, + 582,3,21,10,0,582,583,3,7,3,0,583,584,3,41,20,0,584,148,1,0,0,0, + 585,586,3,49,24,0,586,587,3,11,5,0,587,588,3,21,10,0,588,589,3,7, + 3,0,589,590,3,41,20,0,590,150,1,0,0,0,591,592,3,17,8,0,592,593,3, + 9,4,0,593,594,3,23,11,0,594,595,3,33,16,0,595,152,1,0,0,0,596,597, + 5,58,0,0,597,598,5,58,0,0,598,154,1,0,0,0,599,603,7,32,0,0,600,602, + 7,33,0,0,601,600,1,0,0,0,602,605,1,0,0,0,603,601,1,0,0,0,603,604, + 1,0,0,0,604,156,1,0,0,0,605,603,1,0,0,0,606,607,5,60,0,0,607,158, + 1,0,0,0,608,609,5,62,0,0,609,160,1,0,0,0,610,611,5,40,0,0,611,162, + 1,0,0,0,612,613,5,41,0,0,613,164,1,0,0,0,614,615,5,91,0,0,615,166, + 1,0,0,0,616,617,5,93,0,0,617,168,1,0,0,0,618,619,5,44,0,0,619,170, + 1,0,0,0,620,621,5,61,0,0,621,172,1,0,0,0,622,623,5,58,0,0,623,174, + 1,0,0,0,624,625,5,63,0,0,625,176,1,0,0,0,626,627,5,35,0,0,627,178, + 1,0,0,0,628,629,5,46,0,0,629,180,1,0,0,0,9,0,187,199,202,207,218, + 281,284,603,1,0,1,0 ] - class SubstraitLexer(Lexer): atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] LineComment = 1 BlockComment = 2 @@ -5291,15 +255,15 @@ class SubstraitLexer(Lexer): String = 14 Binary = 15 Timestamp = 16 - TimestampTZ = 17 + Timestamp_TZ = 17 Date = 18 Time = 19 - IntervalYear = 20 - IntervalDay = 21 + Interval_Year = 20 + Interval_Day = 21 UUID = 22 Decimal = 23 - PrecisionTimestamp = 24 - PrecisionTimestampTZ = 25 + Precision_Timestamp = 24 + Precision_Timestamp_TZ = 25 FixedChar = 26 VarChar = 27 FixedBinary = 28 @@ -5309,219 +273,77 @@ class SubstraitLexer(Lexer): Map = 32 ANY = 33 UserDefined = 34 - Bool = 35 - Str = 36 - VBin = 37 - Ts = 38 - TsTZ = 39 - IYear = 40 - IDay = 41 - Dec = 42 - PTs = 43 - PTsTZ = 44 - FChar = 45 - VChar = 46 - FBin = 47 - DOUBLE_COLON = 48 - IDENTIFIER = 49 - O_ANGLE_BRACKET = 50 - C_ANGLE_BRACKET = 51 - OPAREN = 52 - CPAREN = 53 - OBRACKET = 54 - CBRACKET = 55 - COMMA = 56 - EQ = 57 - COLON = 58 - QMARK = 59 - HASH = 60 - DOT = 61 + Geometry = 35 + Bool = 36 + Str = 37 + VBin = 38 + Ts = 39 + TsTZ = 40 + IYear = 41 + IDay = 42 + Dec = 43 + PTs = 44 + PTsTZ = 45 + FChar = 46 + VChar = 47 + FBin = 48 + DOUBLE_COLON = 49 + IDENTIFIER = 50 + O_ANGLE_BRACKET = 51 + C_ANGLE_BRACKET = 52 + OPAREN = 53 + CPAREN = 54 + OBRACKET = 55 + CBRACKET = 56 + COMMA = 57 + EQ = 58 + COLON = 59 + QMARK = 60 + HASH = 61 + DOT = 62 - channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] - modeNames = ["DEFAULT_MODE"] + modeNames = [ "DEFAULT_MODE" ] - literalNames = [ - "", - "'::'", - "'<'", - "'>'", - "'('", - "')'", - "'['", - "']'", - "','", - "'='", - "':'", - "'?'", - "'#'", - "'.'", - ] + literalNames = [ "", + "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", + "':'", "'?'", "'#'", "'.'" ] - symbolicNames = [ - "", - "LineComment", - "BlockComment", - "Whitespace", - "If", - "Then", - "Else", - "Boolean", - "I8", - "I16", - "I32", - "I64", - "FP32", - "FP64", - "String", - "Binary", - "Timestamp", - "TimestampTZ", - "Date", - "Time", - "IntervalYear", - "IntervalDay", - "UUID", - "Decimal", - "PrecisionTimestamp", - "PrecisionTimestampTZ", - "FixedChar", - "VarChar", - "FixedBinary", - "Struct", - "NStruct", - "List", - "Map", - "ANY", - "UserDefined", - "Bool", - "Str", - "VBin", - "Ts", - "TsTZ", - "IYear", - "IDay", - "Dec", - "PTs", - "PTsTZ", - "FChar", - "VChar", - "FBin", - "DOUBLE_COLON", - "IDENTIFIER", - "O_ANGLE_BRACKET", - "C_ANGLE_BRACKET", - "OPAREN", - "CPAREN", - "OBRACKET", - "CBRACKET", - "COMMA", - "EQ", - "COLON", - "QMARK", - "HASH", - "DOT", - ] + symbolicNames = [ "", + "LineComment", "BlockComment", "Whitespace", "If", "Then", "Else", + "Boolean", "I8", "I16", "I32", "I64", "FP32", "FP64", "String", + "Binary", "Timestamp", "Timestamp_TZ", "Date", "Time", "Interval_Year", + "Interval_Day", "UUID", "Decimal", "Precision_Timestamp", "Precision_Timestamp_TZ", + "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", + "List", "Map", "ANY", "UserDefined", "Geometry", "Bool", "Str", + "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", + "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", + "COMMA", "EQ", "COLON", "QMARK", "HASH", "DOT" ] - ruleNames = [ - "LineComment", - "BlockComment", - "Whitespace", - "A", - "B", - "C", - "D", - "E", - "F", - "G", - "H", - "I", - "J", - "K", - "L", - "M", - "N", - "O", - "P", - "Q", - "R", - "S", - "T", - "U", - "V", - "W", - "X", - "Y", - "Z", - "DIGIT", - "INTEGER", - "If", - "Then", - "Else", - "Boolean", - "I8", - "I16", - "I32", - "I64", - "FP32", - "FP64", - "String", - "Binary", - "Timestamp", - "TimestampTZ", - "Date", - "Time", - "IntervalYear", - "IntervalDay", - "UUID", - "Decimal", - "PrecisionTimestamp", - "PrecisionTimestampTZ", - "FixedChar", - "VarChar", - "FixedBinary", - "Struct", - "NStruct", - "List", - "Map", - "ANY", - "UserDefined", - "Bool", - "Str", - "VBin", - "Ts", - "TsTZ", - "IYear", - "IDay", - "Dec", - "PTs", - "PTsTZ", - "FChar", - "VChar", - "FBin", - "DOUBLE_COLON", - "IDENTIFIER", - "O_ANGLE_BRACKET", - "C_ANGLE_BRACKET", - "OPAREN", - "CPAREN", - "OBRACKET", - "CBRACKET", - "COMMA", - "EQ", - "COLON", - "QMARK", - "HASH", - "DOT", - ] + ruleNames = [ "LineComment", "BlockComment", "Whitespace", "A", "B", + "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", + "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", + "Y", "Z", "DIGIT", "INTEGER", "If", "Then", "Else", "Boolean", + "I8", "I16", "I32", "I64", "FP32", "FP64", "String", "Binary", + "Timestamp", "Timestamp_TZ", "Date", "Time", "Interval_Year", + "Interval_Day", "UUID", "Decimal", "Precision_Timestamp", + "Precision_Timestamp_TZ", "FixedChar", "VarChar", "FixedBinary", + "Struct", "NStruct", "List", "Map", "ANY", "UserDefined", + "Geometry", "Bool", "Str", "VBin", "Ts", "TsTZ", "IYear", + "IDay", "Dec", "PTs", "PTsTZ", "FChar", "VChar", "FBin", + "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", + "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", "EQ", + "COLON", "QMARK", "HASH", "DOT" ] grammarFileName = "SubstraitLexer.g4" - def __init__(self, input=None, output: TextIO = sys.stdout): + def __init__(self, input=None, output:TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") - self._interp = LexerATNSimulator( - self, self.atn, self.decisionsToDFA, PredictionContextCache() - ) + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) self._actions = None self._predicates = None + + diff --git a/tests/coverage/antlr_parser/SubstraitLexer.tokens b/tests/coverage/antlr_parser/SubstraitLexer.tokens index 0757be1e2..5cb4a606b 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.tokens +++ b/tests/coverage/antlr_parser/SubstraitLexer.tokens @@ -14,15 +14,15 @@ FP64=13 String=14 Binary=15 Timestamp=16 -TimestampTZ=17 +Timestamp_TZ=17 Date=18 Time=19 -IntervalYear=20 -IntervalDay=21 +Interval_Year=20 +Interval_Day=21 UUID=22 Decimal=23 -PrecisionTimestamp=24 -PrecisionTimestampTZ=25 +Precision_Timestamp=24 +Precision_Timestamp_TZ=25 FixedChar=26 VarChar=27 FixedBinary=28 @@ -32,43 +32,44 @@ List=31 Map=32 ANY=33 UserDefined=34 -Bool=35 -Str=36 -VBin=37 -Ts=38 -TsTZ=39 -IYear=40 -IDay=41 -Dec=42 -PTs=43 -PTsTZ=44 -FChar=45 -VChar=46 -FBin=47 -DOUBLE_COLON=48 -IDENTIFIER=49 -O_ANGLE_BRACKET=50 -C_ANGLE_BRACKET=51 -OPAREN=52 -CPAREN=53 -OBRACKET=54 -CBRACKET=55 -COMMA=56 -EQ=57 -COLON=58 -QMARK=59 -HASH=60 -DOT=61 -'::'=48 -'<'=50 -'>'=51 -'('=52 -')'=53 -'['=54 -']'=55 -','=56 -'='=57 -':'=58 -'?'=59 -'#'=60 -'.'=61 +Geometry=35 +Bool=36 +Str=37 +VBin=38 +Ts=39 +TsTZ=40 +IYear=41 +IDay=42 +Dec=43 +PTs=44 +PTsTZ=45 +FChar=46 +VChar=47 +FBin=48 +DOUBLE_COLON=49 +IDENTIFIER=50 +O_ANGLE_BRACKET=51 +C_ANGLE_BRACKET=52 +OPAREN=53 +CPAREN=54 +OBRACKET=55 +CBRACKET=56 +COMMA=57 +EQ=58 +COLON=59 +QMARK=60 +HASH=61 +DOT=62 +'::'=49 +'<'=51 +'>'=52 +'('=53 +')'=54 +'['=55 +']'=56 +','=57 +'='=58 +':'=59 +'?'=60 +'#'=61 +'.'=62 diff --git a/tests/coverage/antlr_parser/TestFileLexer.interp b/tests/coverage/antlr_parser/TestFileLexer.interp deleted file mode 100644 index 18f88403e..000000000 --- a/tests/coverage/antlr_parser/TestFileLexer.interp +++ /dev/null @@ -1,330 +0,0 @@ -token literal names: -null -'### SUBSTRAIT_SCALAR_TEST:' -null -'### SUBSTRAIT_INCLUDE:' -null -'' -'' -'overlfow' -'rounding' -'ERROR' -'SATURATE' -'SILENT' -'TIE_TO_EVEN' -'NAN' -null -null -null -null -null -null -null -null -'P' -'T' -'Y' -'M' -'D' -'H' -'S' -'F' -null -null -'null' -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -null -'::' -null -'<' -'>' -'(' -')' -'[' -']' -',' -'=' -':' -'?' -'#' -'.' - -token symbolic names: -null -SUBSTRAIT_SCALAR_TEST -FORMAT_VERSION -SUBSTRAIT_INCLUDE -DESCRIPTION_LINE -ERROR_RESULT -UNDEFINED_RESULT -OVERFLOW -ROUNDING -ERROR -SATURATE -SILENT -TIE_TO_EVEN -NAN -INTEGER_LITERAL -DECIMAL_LITERAL -FLOAT_LITERAL -BOOLEAN_LITERAL -TIMESTAMP_TZ_LITERAL -TIMESTAMP_LITERAL -TIME_LITERAL -DATE_LITERAL -PERIOD_PREFIX -TIME_PREFIX -YEAR_SUFFIX -M_SUFFIX -DAY_SUFFIX -HOUR_SUFFIX -SECOND_SUFFIX -FRACTIONAL_SECOND_SUFFIX -INTERVAL_YEAR_LITERAL -INTERVAL_DAY_LITERAL -NULL_LITERAL -STRING_LITERAL -LineComment -BlockComment -Whitespace -If -Then -Else -Boolean -I8 -I16 -I32 -I64 -FP32 -FP64 -String -Binary -Timestamp -TimestampTZ -Date -Time -IntervalYear -IntervalDay -UUID -Decimal -PrecisionTimestamp -PrecisionTimestampTZ -FixedChar -VarChar -FixedBinary -Struct -NStruct -List -Map -ANY -UserDefined -Bool -Str -VBin -Ts -TsTZ -IYear -IDay -Dec -PTs -PTsTZ -FChar -VChar -FBin -DOUBLE_COLON -IDENTIFIER -O_ANGLE_BRACKET -C_ANGLE_BRACKET -OPAREN -CPAREN -OBRACKET -CBRACKET -COMMA -EQ -COLON -QMARK -HASH -DOT - -rule names: -SUBSTRAIT_SCALAR_TEST -FORMAT_VERSION -SUBSTRAIT_INCLUDE -DESCRIPTION_LINE -ERROR_RESULT -UNDEFINED_RESULT -OVERFLOW -ROUNDING -ERROR -SATURATE -SILENT -TIE_TO_EVEN -NAN -INTEGER_LITERAL -DECIMAL_LITERAL -FLOAT_LITERAL -BOOLEAN_LITERAL -FourDigits -TwoDigits -TIMESTAMP_TZ_LITERAL -TIMESTAMP_LITERAL -TIME_LITERAL -DATE_LITERAL -PERIOD_PREFIX -TIME_PREFIX -YEAR_SUFFIX -M_SUFFIX -DAY_SUFFIX -HOUR_SUFFIX -SECOND_SUFFIX -FRACTIONAL_SECOND_SUFFIX -INTERVAL_YEAR_LITERAL -INTERVAL_DAY_LITERAL -TIME_INTERVAL -NULL_LITERAL -STRING_LITERAL -LineComment -BlockComment -Whitespace -A -B -C -D -E -F -G -H -I -J -K -L -M -N -O -P -Q -R -S -T -U -V -W -X -Y -Z -DIGIT -INTEGER -If -Then -Else -Boolean -I8 -I16 -I32 -I64 -FP32 -FP64 -String -Binary -Timestamp -TimestampTZ -Date -Time -IntervalYear -IntervalDay -UUID -Decimal -PrecisionTimestamp -PrecisionTimestampTZ -FixedChar -VarChar -FixedBinary -Struct -NStruct -List -Map -ANY -UserDefined -Bool -Str -VBin -Ts -TsTZ -IYear -IDay -Dec -PTs -PTsTZ -FChar -VChar -FBin -DOUBLE_COLON -IDENTIFIER -O_ANGLE_BRACKET -C_ANGLE_BRACKET -OPAREN -CPAREN -OBRACKET -CBRACKET -COMMA -EQ -COLON -QMARK -HASH -DOT - -channel names: -DEFAULT_TOKEN_CHANNEL -HIDDEN - -mode names: -DEFAULT_MODE - -atn: -[4, 0, 94, 1118, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 4, 1, 281, 8, 1, 11, 1, 12, 1, 282, 1, 1, 1, 1, 4, 1, 287, 8, 1, 11, 1, 12, 1, 288, 3, 1, 291, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 320, 8, 3, 10, 3, 12, 3, 323, 9, 3, 1, 3, 3, 3, 326, 8, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 3, 13, 409, 8, 13, 1, 13, 1, 13, 1, 14, 3, 14, 414, 8, 14, 1, 14, 4, 14, 417, 8, 14, 11, 14, 12, 14, 418, 1, 14, 1, 14, 4, 14, 423, 8, 14, 11, 14, 12, 14, 424, 3, 14, 427, 8, 14, 1, 15, 3, 15, 430, 8, 15, 1, 15, 4, 15, 433, 8, 15, 11, 15, 12, 15, 434, 1, 15, 1, 15, 5, 15, 439, 8, 15, 10, 15, 12, 15, 442, 9, 15, 3, 15, 444, 8, 15, 1, 15, 1, 15, 3, 15, 448, 8, 15, 1, 15, 4, 15, 451, 8, 15, 11, 15, 12, 15, 452, 3, 15, 455, 8, 15, 1, 15, 3, 15, 458, 8, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 473, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 484, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 4, 19, 508, 8, 19, 11, 19, 12, 19, 509, 3, 19, 512, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 4, 20, 534, 8, 20, 11, 20, 12, 20, 535, 3, 20, 538, 8, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 4, 21, 550, 8, 21, 11, 21, 12, 21, 551, 3, 21, 554, 8, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 589, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 599, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 608, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 618, 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 625, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 630, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 635, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 642, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 647, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 654, 8, 33, 1, 33, 1, 33, 1, 33, 3, 33, 659, 8, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 5, 35, 672, 8, 35, 10, 35, 12, 35, 675, 9, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 683, 8, 36, 10, 36, 12, 36, 686, 9, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 4, 37, 695, 8, 37, 11, 37, 12, 37, 696, 1, 37, 3, 37, 700, 8, 37, 1, 37, 5, 37, 703, 8, 37, 10, 37, 12, 37, 706, 9, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 4, 38, 714, 8, 38, 11, 38, 12, 38, 715, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 41, 1, 41, 1, 42, 1, 42, 1, 43, 1, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 47, 1, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 53, 1, 53, 1, 54, 1, 54, 1, 55, 1, 55, 1, 56, 1, 56, 1, 57, 1, 57, 1, 58, 1, 58, 1, 59, 1, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 64, 1, 64, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 5, 66, 777, 8, 66, 10, 66, 12, 66, 780, 9, 66, 3, 66, 782, 8, 66, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 5, 112, 1090, 8, 112, 10, 112, 12, 112, 1093, 9, 112, 1, 113, 1, 113, 1, 114, 1, 114, 1, 115, 1, 115, 1, 116, 1, 116, 1, 117, 1, 117, 1, 118, 1, 118, 1, 119, 1, 119, 1, 120, 1, 120, 1, 121, 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 1, 124, 1, 124, 0, 0, 125, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 0, 37, 0, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 30, 65, 31, 67, 0, 69, 32, 71, 33, 73, 34, 75, 35, 77, 36, 79, 0, 81, 0, 83, 0, 85, 0, 87, 0, 89, 0, 91, 0, 93, 0, 95, 0, 97, 0, 99, 0, 101, 0, 103, 0, 105, 0, 107, 0, 109, 0, 111, 0, 113, 0, 115, 0, 117, 0, 119, 0, 121, 0, 123, 0, 125, 0, 127, 0, 129, 0, 131, 0, 133, 0, 135, 37, 137, 38, 139, 39, 141, 40, 143, 41, 145, 42, 147, 43, 149, 44, 151, 45, 153, 46, 155, 47, 157, 48, 159, 49, 161, 50, 163, 51, 165, 52, 167, 53, 169, 54, 171, 55, 173, 56, 175, 57, 177, 58, 179, 59, 181, 60, 183, 61, 185, 62, 187, 63, 189, 64, 191, 65, 193, 66, 195, 67, 197, 68, 199, 69, 201, 70, 203, 71, 205, 72, 207, 73, 209, 74, 211, 75, 213, 76, 215, 77, 217, 78, 219, 79, 221, 80, 223, 81, 225, 82, 227, 83, 229, 84, 231, 85, 233, 86, 235, 87, 237, 88, 239, 89, 241, 90, 243, 91, 245, 92, 247, 93, 249, 94, 1, 0, 36, 2, 0, 10, 10, 13, 13, 2, 0, 43, 43, 45, 45, 1, 0, 48, 57, 2, 0, 69, 69, 101, 101, 2, 0, 39, 39, 92, 92, 1, 0, 42, 42, 2, 0, 42, 42, 47, 47, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 71, 71, 103, 103, 2, 0, 72, 72, 104, 104, 2, 0, 73, 73, 105, 105, 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 76, 76, 108, 108, 2, 0, 77, 77, 109, 109, 2, 0, 78, 78, 110, 110, 2, 0, 79, 79, 111, 111, 2, 0, 80, 80, 112, 112, 2, 0, 81, 81, 113, 113, 2, 0, 82, 82, 114, 114, 2, 0, 83, 83, 115, 115, 2, 0, 84, 84, 116, 116, 2, 0, 85, 85, 117, 117, 2, 0, 86, 86, 118, 118, 2, 0, 87, 87, 119, 119, 2, 0, 88, 88, 120, 120, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 1, 0, 49, 57, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, 95, 97, 122, 1139, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 1, 251, 1, 0, 0, 0, 3, 278, 1, 0, 0, 0, 5, 292, 1, 0, 0, 0, 7, 315, 1, 0, 0, 0, 9, 329, 1, 0, 0, 0, 11, 338, 1, 0, 0, 0, 13, 351, 1, 0, 0, 0, 15, 360, 1, 0, 0, 0, 17, 369, 1, 0, 0, 0, 19, 375, 1, 0, 0, 0, 21, 384, 1, 0, 0, 0, 23, 391, 1, 0, 0, 0, 25, 403, 1, 0, 0, 0, 27, 408, 1, 0, 0, 0, 29, 413, 1, 0, 0, 0, 31, 472, 1, 0, 0, 0, 33, 483, 1, 0, 0, 0, 35, 485, 1, 0, 0, 0, 37, 490, 1, 0, 0, 0, 39, 493, 1, 0, 0, 0, 41, 519, 1, 0, 0, 0, 43, 541, 1, 0, 0, 0, 45, 557, 1, 0, 0, 0, 47, 565, 1, 0, 0, 0, 49, 567, 1, 0, 0, 0, 51, 569, 1, 0, 0, 0, 53, 571, 1, 0, 0, 0, 55, 573, 1, 0, 0, 0, 57, 575, 1, 0, 0, 0, 59, 577, 1, 0, 0, 0, 61, 579, 1, 0, 0, 0, 63, 598, 1, 0, 0, 0, 65, 617, 1, 0, 0, 0, 67, 658, 1, 0, 0, 0, 69, 660, 1, 0, 0, 0, 71, 665, 1, 0, 0, 0, 73, 678, 1, 0, 0, 0, 75, 689, 1, 0, 0, 0, 77, 713, 1, 0, 0, 0, 79, 719, 1, 0, 0, 0, 81, 721, 1, 0, 0, 0, 83, 723, 1, 0, 0, 0, 85, 725, 1, 0, 0, 0, 87, 727, 1, 0, 0, 0, 89, 729, 1, 0, 0, 0, 91, 731, 1, 0, 0, 0, 93, 733, 1, 0, 0, 0, 95, 735, 1, 0, 0, 0, 97, 737, 1, 0, 0, 0, 99, 739, 1, 0, 0, 0, 101, 741, 1, 0, 0, 0, 103, 743, 1, 0, 0, 0, 105, 745, 1, 0, 0, 0, 107, 747, 1, 0, 0, 0, 109, 749, 1, 0, 0, 0, 111, 751, 1, 0, 0, 0, 113, 753, 1, 0, 0, 0, 115, 755, 1, 0, 0, 0, 117, 757, 1, 0, 0, 0, 119, 759, 1, 0, 0, 0, 121, 761, 1, 0, 0, 0, 123, 763, 1, 0, 0, 0, 125, 765, 1, 0, 0, 0, 127, 767, 1, 0, 0, 0, 129, 769, 1, 0, 0, 0, 131, 771, 1, 0, 0, 0, 133, 781, 1, 0, 0, 0, 135, 783, 1, 0, 0, 0, 137, 786, 1, 0, 0, 0, 139, 791, 1, 0, 0, 0, 141, 796, 1, 0, 0, 0, 143, 804, 1, 0, 0, 0, 145, 807, 1, 0, 0, 0, 147, 811, 1, 0, 0, 0, 149, 815, 1, 0, 0, 0, 151, 819, 1, 0, 0, 0, 153, 824, 1, 0, 0, 0, 155, 829, 1, 0, 0, 0, 157, 836, 1, 0, 0, 0, 159, 843, 1, 0, 0, 0, 161, 853, 1, 0, 0, 0, 163, 866, 1, 0, 0, 0, 165, 871, 1, 0, 0, 0, 167, 876, 1, 0, 0, 0, 169, 890, 1, 0, 0, 0, 171, 903, 1, 0, 0, 0, 173, 908, 1, 0, 0, 0, 175, 916, 1, 0, 0, 0, 177, 936, 1, 0, 0, 0, 179, 959, 1, 0, 0, 0, 181, 969, 1, 0, 0, 0, 183, 977, 1, 0, 0, 0, 185, 989, 1, 0, 0, 0, 187, 996, 1, 0, 0, 0, 189, 1004, 1, 0, 0, 0, 191, 1009, 1, 0, 0, 0, 193, 1013, 1, 0, 0, 0, 195, 1017, 1, 0, 0, 0, 197, 1020, 1, 0, 0, 0, 199, 1025, 1, 0, 0, 0, 201, 1029, 1, 0, 0, 0, 203, 1034, 1, 0, 0, 0, 205, 1037, 1, 0, 0, 0, 207, 1042, 1, 0, 0, 0, 209, 1048, 1, 0, 0, 0, 211, 1053, 1, 0, 0, 0, 213, 1057, 1, 0, 0, 0, 215, 1061, 1, 0, 0, 0, 217, 1067, 1, 0, 0, 0, 219, 1073, 1, 0, 0, 0, 221, 1079, 1, 0, 0, 0, 223, 1084, 1, 0, 0, 0, 225, 1087, 1, 0, 0, 0, 227, 1094, 1, 0, 0, 0, 229, 1096, 1, 0, 0, 0, 231, 1098, 1, 0, 0, 0, 233, 1100, 1, 0, 0, 0, 235, 1102, 1, 0, 0, 0, 237, 1104, 1, 0, 0, 0, 239, 1106, 1, 0, 0, 0, 241, 1108, 1, 0, 0, 0, 243, 1110, 1, 0, 0, 0, 245, 1112, 1, 0, 0, 0, 247, 1114, 1, 0, 0, 0, 249, 1116, 1, 0, 0, 0, 251, 252, 5, 35, 0, 0, 252, 253, 5, 35, 0, 0, 253, 254, 5, 35, 0, 0, 254, 255, 5, 32, 0, 0, 255, 256, 5, 83, 0, 0, 256, 257, 5, 85, 0, 0, 257, 258, 5, 66, 0, 0, 258, 259, 5, 83, 0, 0, 259, 260, 5, 84, 0, 0, 260, 261, 5, 82, 0, 0, 261, 262, 5, 65, 0, 0, 262, 263, 5, 73, 0, 0, 263, 264, 5, 84, 0, 0, 264, 265, 5, 95, 0, 0, 265, 266, 5, 83, 0, 0, 266, 267, 5, 67, 0, 0, 267, 268, 5, 65, 0, 0, 268, 269, 5, 76, 0, 0, 269, 270, 5, 65, 0, 0, 270, 271, 5, 82, 0, 0, 271, 272, 5, 95, 0, 0, 272, 273, 5, 84, 0, 0, 273, 274, 5, 69, 0, 0, 274, 275, 5, 83, 0, 0, 275, 276, 5, 84, 0, 0, 276, 277, 5, 58, 0, 0, 277, 2, 1, 0, 0, 0, 278, 280, 5, 118, 0, 0, 279, 281, 3, 131, 65, 0, 280, 279, 1, 0, 0, 0, 281, 282, 1, 0, 0, 0, 282, 280, 1, 0, 0, 0, 282, 283, 1, 0, 0, 0, 283, 290, 1, 0, 0, 0, 284, 286, 5, 46, 0, 0, 285, 287, 3, 131, 65, 0, 286, 285, 1, 0, 0, 0, 287, 288, 1, 0, 0, 0, 288, 286, 1, 0, 0, 0, 288, 289, 1, 0, 0, 0, 289, 291, 1, 0, 0, 0, 290, 284, 1, 0, 0, 0, 290, 291, 1, 0, 0, 0, 291, 4, 1, 0, 0, 0, 292, 293, 5, 35, 0, 0, 293, 294, 5, 35, 0, 0, 294, 295, 5, 35, 0, 0, 295, 296, 5, 32, 0, 0, 296, 297, 5, 83, 0, 0, 297, 298, 5, 85, 0, 0, 298, 299, 5, 66, 0, 0, 299, 300, 5, 83, 0, 0, 300, 301, 5, 84, 0, 0, 301, 302, 5, 82, 0, 0, 302, 303, 5, 65, 0, 0, 303, 304, 5, 73, 0, 0, 304, 305, 5, 84, 0, 0, 305, 306, 5, 95, 0, 0, 306, 307, 5, 73, 0, 0, 307, 308, 5, 78, 0, 0, 308, 309, 5, 67, 0, 0, 309, 310, 5, 76, 0, 0, 310, 311, 5, 85, 0, 0, 311, 312, 5, 68, 0, 0, 312, 313, 5, 69, 0, 0, 313, 314, 5, 58, 0, 0, 314, 6, 1, 0, 0, 0, 315, 316, 5, 35, 0, 0, 316, 317, 5, 32, 0, 0, 317, 321, 1, 0, 0, 0, 318, 320, 8, 0, 0, 0, 319, 318, 1, 0, 0, 0, 320, 323, 1, 0, 0, 0, 321, 319, 1, 0, 0, 0, 321, 322, 1, 0, 0, 0, 322, 325, 1, 0, 0, 0, 323, 321, 1, 0, 0, 0, 324, 326, 5, 13, 0, 0, 325, 324, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 327, 1, 0, 0, 0, 327, 328, 5, 10, 0, 0, 328, 8, 1, 0, 0, 0, 329, 330, 5, 60, 0, 0, 330, 331, 5, 33, 0, 0, 331, 332, 5, 69, 0, 0, 332, 333, 5, 82, 0, 0, 333, 334, 5, 82, 0, 0, 334, 335, 5, 79, 0, 0, 335, 336, 5, 82, 0, 0, 336, 337, 5, 62, 0, 0, 337, 10, 1, 0, 0, 0, 338, 339, 5, 60, 0, 0, 339, 340, 5, 33, 0, 0, 340, 341, 5, 85, 0, 0, 341, 342, 5, 78, 0, 0, 342, 343, 5, 68, 0, 0, 343, 344, 5, 69, 0, 0, 344, 345, 5, 70, 0, 0, 345, 346, 5, 73, 0, 0, 346, 347, 5, 78, 0, 0, 347, 348, 5, 69, 0, 0, 348, 349, 5, 68, 0, 0, 349, 350, 5, 62, 0, 0, 350, 12, 1, 0, 0, 0, 351, 352, 5, 111, 0, 0, 352, 353, 5, 118, 0, 0, 353, 354, 5, 101, 0, 0, 354, 355, 5, 114, 0, 0, 355, 356, 5, 108, 0, 0, 356, 357, 5, 102, 0, 0, 357, 358, 5, 111, 0, 0, 358, 359, 5, 119, 0, 0, 359, 14, 1, 0, 0, 0, 360, 361, 5, 114, 0, 0, 361, 362, 5, 111, 0, 0, 362, 363, 5, 117, 0, 0, 363, 364, 5, 110, 0, 0, 364, 365, 5, 100, 0, 0, 365, 366, 5, 105, 0, 0, 366, 367, 5, 110, 0, 0, 367, 368, 5, 103, 0, 0, 368, 16, 1, 0, 0, 0, 369, 370, 5, 69, 0, 0, 370, 371, 5, 82, 0, 0, 371, 372, 5, 82, 0, 0, 372, 373, 5, 79, 0, 0, 373, 374, 5, 82, 0, 0, 374, 18, 1, 0, 0, 0, 375, 376, 5, 83, 0, 0, 376, 377, 5, 65, 0, 0, 377, 378, 5, 84, 0, 0, 378, 379, 5, 85, 0, 0, 379, 380, 5, 82, 0, 0, 380, 381, 5, 65, 0, 0, 381, 382, 5, 84, 0, 0, 382, 383, 5, 69, 0, 0, 383, 20, 1, 0, 0, 0, 384, 385, 5, 83, 0, 0, 385, 386, 5, 73, 0, 0, 386, 387, 5, 76, 0, 0, 387, 388, 5, 69, 0, 0, 388, 389, 5, 78, 0, 0, 389, 390, 5, 84, 0, 0, 390, 22, 1, 0, 0, 0, 391, 392, 5, 84, 0, 0, 392, 393, 5, 73, 0, 0, 393, 394, 5, 69, 0, 0, 394, 395, 5, 95, 0, 0, 395, 396, 5, 84, 0, 0, 396, 397, 5, 79, 0, 0, 397, 398, 5, 95, 0, 0, 398, 399, 5, 69, 0, 0, 399, 400, 5, 86, 0, 0, 400, 401, 5, 69, 0, 0, 401, 402, 5, 78, 0, 0, 402, 24, 1, 0, 0, 0, 403, 404, 5, 78, 0, 0, 404, 405, 5, 65, 0, 0, 405, 406, 5, 78, 0, 0, 406, 26, 1, 0, 0, 0, 407, 409, 7, 1, 0, 0, 408, 407, 1, 0, 0, 0, 408, 409, 1, 0, 0, 0, 409, 410, 1, 0, 0, 0, 410, 411, 3, 133, 66, 0, 411, 28, 1, 0, 0, 0, 412, 414, 7, 1, 0, 0, 413, 412, 1, 0, 0, 0, 413, 414, 1, 0, 0, 0, 414, 416, 1, 0, 0, 0, 415, 417, 7, 2, 0, 0, 416, 415, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 416, 1, 0, 0, 0, 418, 419, 1, 0, 0, 0, 419, 426, 1, 0, 0, 0, 420, 422, 5, 46, 0, 0, 421, 423, 7, 2, 0, 0, 422, 421, 1, 0, 0, 0, 423, 424, 1, 0, 0, 0, 424, 422, 1, 0, 0, 0, 424, 425, 1, 0, 0, 0, 425, 427, 1, 0, 0, 0, 426, 420, 1, 0, 0, 0, 426, 427, 1, 0, 0, 0, 427, 30, 1, 0, 0, 0, 428, 430, 7, 1, 0, 0, 429, 428, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430, 432, 1, 0, 0, 0, 431, 433, 7, 2, 0, 0, 432, 431, 1, 0, 0, 0, 433, 434, 1, 0, 0, 0, 434, 432, 1, 0, 0, 0, 434, 435, 1, 0, 0, 0, 435, 443, 1, 0, 0, 0, 436, 440, 5, 46, 0, 0, 437, 439, 7, 2, 0, 0, 438, 437, 1, 0, 0, 0, 439, 442, 1, 0, 0, 0, 440, 438, 1, 0, 0, 0, 440, 441, 1, 0, 0, 0, 441, 444, 1, 0, 0, 0, 442, 440, 1, 0, 0, 0, 443, 436, 1, 0, 0, 0, 443, 444, 1, 0, 0, 0, 444, 454, 1, 0, 0, 0, 445, 447, 7, 3, 0, 0, 446, 448, 7, 1, 0, 0, 447, 446, 1, 0, 0, 0, 447, 448, 1, 0, 0, 0, 448, 450, 1, 0, 0, 0, 449, 451, 7, 2, 0, 0, 450, 449, 1, 0, 0, 0, 451, 452, 1, 0, 0, 0, 452, 450, 1, 0, 0, 0, 452, 453, 1, 0, 0, 0, 453, 455, 1, 0, 0, 0, 454, 445, 1, 0, 0, 0, 454, 455, 1, 0, 0, 0, 455, 473, 1, 0, 0, 0, 456, 458, 7, 1, 0, 0, 457, 456, 1, 0, 0, 0, 457, 458, 1, 0, 0, 0, 458, 459, 1, 0, 0, 0, 459, 460, 5, 105, 0, 0, 460, 461, 5, 110, 0, 0, 461, 473, 5, 102, 0, 0, 462, 463, 5, 110, 0, 0, 463, 464, 5, 97, 0, 0, 464, 473, 5, 110, 0, 0, 465, 466, 5, 78, 0, 0, 466, 467, 5, 97, 0, 0, 467, 473, 5, 78, 0, 0, 468, 469, 5, 115, 0, 0, 469, 470, 5, 110, 0, 0, 470, 471, 5, 97, 0, 0, 471, 473, 5, 110, 0, 0, 472, 429, 1, 0, 0, 0, 472, 457, 1, 0, 0, 0, 472, 462, 1, 0, 0, 0, 472, 465, 1, 0, 0, 0, 472, 468, 1, 0, 0, 0, 473, 32, 1, 0, 0, 0, 474, 475, 5, 116, 0, 0, 475, 476, 5, 114, 0, 0, 476, 477, 5, 117, 0, 0, 477, 484, 5, 101, 0, 0, 478, 479, 5, 102, 0, 0, 479, 480, 5, 97, 0, 0, 480, 481, 5, 108, 0, 0, 481, 482, 5, 115, 0, 0, 482, 484, 5, 101, 0, 0, 483, 474, 1, 0, 0, 0, 483, 478, 1, 0, 0, 0, 484, 34, 1, 0, 0, 0, 485, 486, 7, 2, 0, 0, 486, 487, 7, 2, 0, 0, 487, 488, 7, 2, 0, 0, 488, 489, 7, 2, 0, 0, 489, 36, 1, 0, 0, 0, 490, 491, 7, 2, 0, 0, 491, 492, 7, 2, 0, 0, 492, 38, 1, 0, 0, 0, 493, 494, 5, 39, 0, 0, 494, 495, 3, 35, 17, 0, 495, 496, 5, 45, 0, 0, 496, 497, 3, 37, 18, 0, 497, 498, 5, 45, 0, 0, 498, 499, 3, 37, 18, 0, 499, 500, 5, 84, 0, 0, 500, 501, 3, 37, 18, 0, 501, 502, 5, 58, 0, 0, 502, 503, 3, 37, 18, 0, 503, 504, 5, 58, 0, 0, 504, 511, 3, 37, 18, 0, 505, 507, 5, 46, 0, 0, 506, 508, 7, 2, 0, 0, 507, 506, 1, 0, 0, 0, 508, 509, 1, 0, 0, 0, 509, 507, 1, 0, 0, 0, 509, 510, 1, 0, 0, 0, 510, 512, 1, 0, 0, 0, 511, 505, 1, 0, 0, 0, 511, 512, 1, 0, 0, 0, 512, 513, 1, 0, 0, 0, 513, 514, 7, 1, 0, 0, 514, 515, 3, 37, 18, 0, 515, 516, 5, 58, 0, 0, 516, 517, 3, 37, 18, 0, 517, 518, 5, 39, 0, 0, 518, 40, 1, 0, 0, 0, 519, 520, 5, 39, 0, 0, 520, 521, 3, 35, 17, 0, 521, 522, 5, 45, 0, 0, 522, 523, 3, 37, 18, 0, 523, 524, 5, 45, 0, 0, 524, 525, 3, 37, 18, 0, 525, 526, 5, 84, 0, 0, 526, 527, 3, 37, 18, 0, 527, 528, 5, 58, 0, 0, 528, 529, 3, 37, 18, 0, 529, 530, 5, 58, 0, 0, 530, 537, 3, 37, 18, 0, 531, 533, 5, 46, 0, 0, 532, 534, 7, 2, 0, 0, 533, 532, 1, 0, 0, 0, 534, 535, 1, 0, 0, 0, 535, 533, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 538, 1, 0, 0, 0, 537, 531, 1, 0, 0, 0, 537, 538, 1, 0, 0, 0, 538, 539, 1, 0, 0, 0, 539, 540, 5, 39, 0, 0, 540, 42, 1, 0, 0, 0, 541, 542, 5, 39, 0, 0, 542, 543, 3, 37, 18, 0, 543, 544, 5, 58, 0, 0, 544, 545, 3, 37, 18, 0, 545, 546, 5, 58, 0, 0, 546, 553, 3, 37, 18, 0, 547, 549, 5, 46, 0, 0, 548, 550, 7, 2, 0, 0, 549, 548, 1, 0, 0, 0, 550, 551, 1, 0, 0, 0, 551, 549, 1, 0, 0, 0, 551, 552, 1, 0, 0, 0, 552, 554, 1, 0, 0, 0, 553, 547, 1, 0, 0, 0, 553, 554, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 556, 5, 39, 0, 0, 556, 44, 1, 0, 0, 0, 557, 558, 5, 39, 0, 0, 558, 559, 3, 35, 17, 0, 559, 560, 5, 45, 0, 0, 560, 561, 3, 37, 18, 0, 561, 562, 5, 45, 0, 0, 562, 563, 3, 37, 18, 0, 563, 564, 5, 39, 0, 0, 564, 46, 1, 0, 0, 0, 565, 566, 5, 80, 0, 0, 566, 48, 1, 0, 0, 0, 567, 568, 5, 84, 0, 0, 568, 50, 1, 0, 0, 0, 569, 570, 5, 89, 0, 0, 570, 52, 1, 0, 0, 0, 571, 572, 5, 77, 0, 0, 572, 54, 1, 0, 0, 0, 573, 574, 5, 68, 0, 0, 574, 56, 1, 0, 0, 0, 575, 576, 5, 72, 0, 0, 576, 58, 1, 0, 0, 0, 577, 578, 5, 83, 0, 0, 578, 60, 1, 0, 0, 0, 579, 580, 5, 70, 0, 0, 580, 62, 1, 0, 0, 0, 581, 582, 5, 39, 0, 0, 582, 583, 3, 47, 23, 0, 583, 584, 3, 27, 13, 0, 584, 588, 3, 51, 25, 0, 585, 586, 3, 27, 13, 0, 586, 587, 3, 53, 26, 0, 587, 589, 1, 0, 0, 0, 588, 585, 1, 0, 0, 0, 588, 589, 1, 0, 0, 0, 589, 590, 1, 0, 0, 0, 590, 591, 5, 39, 0, 0, 591, 599, 1, 0, 0, 0, 592, 593, 5, 39, 0, 0, 593, 594, 3, 47, 23, 0, 594, 595, 3, 27, 13, 0, 595, 596, 3, 53, 26, 0, 596, 597, 5, 39, 0, 0, 597, 599, 1, 0, 0, 0, 598, 581, 1, 0, 0, 0, 598, 592, 1, 0, 0, 0, 599, 64, 1, 0, 0, 0, 600, 601, 5, 39, 0, 0, 601, 602, 3, 47, 23, 0, 602, 603, 3, 27, 13, 0, 603, 607, 3, 55, 27, 0, 604, 605, 3, 49, 24, 0, 605, 606, 3, 67, 33, 0, 606, 608, 1, 0, 0, 0, 607, 604, 1, 0, 0, 0, 607, 608, 1, 0, 0, 0, 608, 609, 1, 0, 0, 0, 609, 610, 5, 39, 0, 0, 610, 618, 1, 0, 0, 0, 611, 612, 5, 39, 0, 0, 612, 613, 3, 47, 23, 0, 613, 614, 3, 49, 24, 0, 614, 615, 3, 67, 33, 0, 615, 616, 5, 39, 0, 0, 616, 618, 1, 0, 0, 0, 617, 600, 1, 0, 0, 0, 617, 611, 1, 0, 0, 0, 618, 66, 1, 0, 0, 0, 619, 620, 3, 27, 13, 0, 620, 624, 3, 57, 28, 0, 621, 622, 3, 27, 13, 0, 622, 623, 3, 53, 26, 0, 623, 625, 1, 0, 0, 0, 624, 621, 1, 0, 0, 0, 624, 625, 1, 0, 0, 0, 625, 629, 1, 0, 0, 0, 626, 627, 3, 27, 13, 0, 627, 628, 3, 59, 29, 0, 628, 630, 1, 0, 0, 0, 629, 626, 1, 0, 0, 0, 629, 630, 1, 0, 0, 0, 630, 634, 1, 0, 0, 0, 631, 632, 3, 27, 13, 0, 632, 633, 3, 61, 30, 0, 633, 635, 1, 0, 0, 0, 634, 631, 1, 0, 0, 0, 634, 635, 1, 0, 0, 0, 635, 659, 1, 0, 0, 0, 636, 637, 3, 27, 13, 0, 637, 641, 3, 53, 26, 0, 638, 639, 3, 27, 13, 0, 639, 640, 3, 59, 29, 0, 640, 642, 1, 0, 0, 0, 641, 638, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 646, 1, 0, 0, 0, 643, 644, 3, 27, 13, 0, 644, 645, 3, 61, 30, 0, 645, 647, 1, 0, 0, 0, 646, 643, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 659, 1, 0, 0, 0, 648, 649, 3, 27, 13, 0, 649, 653, 3, 59, 29, 0, 650, 651, 3, 27, 13, 0, 651, 652, 3, 61, 30, 0, 652, 654, 1, 0, 0, 0, 653, 650, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 659, 1, 0, 0, 0, 655, 656, 3, 27, 13, 0, 656, 657, 3, 61, 30, 0, 657, 659, 1, 0, 0, 0, 658, 619, 1, 0, 0, 0, 658, 636, 1, 0, 0, 0, 658, 648, 1, 0, 0, 0, 658, 655, 1, 0, 0, 0, 659, 68, 1, 0, 0, 0, 660, 661, 5, 110, 0, 0, 661, 662, 5, 117, 0, 0, 662, 663, 5, 108, 0, 0, 663, 664, 5, 108, 0, 0, 664, 70, 1, 0, 0, 0, 665, 673, 5, 39, 0, 0, 666, 667, 5, 92, 0, 0, 667, 672, 9, 0, 0, 0, 668, 669, 5, 39, 0, 0, 669, 672, 5, 39, 0, 0, 670, 672, 8, 4, 0, 0, 671, 666, 1, 0, 0, 0, 671, 668, 1, 0, 0, 0, 671, 670, 1, 0, 0, 0, 672, 675, 1, 0, 0, 0, 673, 671, 1, 0, 0, 0, 673, 674, 1, 0, 0, 0, 674, 676, 1, 0, 0, 0, 675, 673, 1, 0, 0, 0, 676, 677, 5, 39, 0, 0, 677, 72, 1, 0, 0, 0, 678, 679, 5, 47, 0, 0, 679, 680, 5, 47, 0, 0, 680, 684, 1, 0, 0, 0, 681, 683, 8, 0, 0, 0, 682, 681, 1, 0, 0, 0, 683, 686, 1, 0, 0, 0, 684, 682, 1, 0, 0, 0, 684, 685, 1, 0, 0, 0, 685, 687, 1, 0, 0, 0, 686, 684, 1, 0, 0, 0, 687, 688, 6, 36, 0, 0, 688, 74, 1, 0, 0, 0, 689, 690, 5, 47, 0, 0, 690, 691, 5, 42, 0, 0, 691, 699, 1, 0, 0, 0, 692, 700, 8, 5, 0, 0, 693, 695, 5, 42, 0, 0, 694, 693, 1, 0, 0, 0, 695, 696, 1, 0, 0, 0, 696, 694, 1, 0, 0, 0, 696, 697, 1, 0, 0, 0, 697, 698, 1, 0, 0, 0, 698, 700, 8, 6, 0, 0, 699, 692, 1, 0, 0, 0, 699, 694, 1, 0, 0, 0, 700, 704, 1, 0, 0, 0, 701, 703, 5, 42, 0, 0, 702, 701, 1, 0, 0, 0, 703, 706, 1, 0, 0, 0, 704, 702, 1, 0, 0, 0, 704, 705, 1, 0, 0, 0, 705, 707, 1, 0, 0, 0, 706, 704, 1, 0, 0, 0, 707, 708, 5, 42, 0, 0, 708, 709, 5, 47, 0, 0, 709, 710, 1, 0, 0, 0, 710, 711, 6, 37, 0, 0, 711, 76, 1, 0, 0, 0, 712, 714, 7, 7, 0, 0, 713, 712, 1, 0, 0, 0, 714, 715, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 717, 1, 0, 0, 0, 717, 718, 6, 38, 0, 0, 718, 78, 1, 0, 0, 0, 719, 720, 7, 8, 0, 0, 720, 80, 1, 0, 0, 0, 721, 722, 7, 9, 0, 0, 722, 82, 1, 0, 0, 0, 723, 724, 7, 10, 0, 0, 724, 84, 1, 0, 0, 0, 725, 726, 7, 11, 0, 0, 726, 86, 1, 0, 0, 0, 727, 728, 7, 3, 0, 0, 728, 88, 1, 0, 0, 0, 729, 730, 7, 12, 0, 0, 730, 90, 1, 0, 0, 0, 731, 732, 7, 13, 0, 0, 732, 92, 1, 0, 0, 0, 733, 734, 7, 14, 0, 0, 734, 94, 1, 0, 0, 0, 735, 736, 7, 15, 0, 0, 736, 96, 1, 0, 0, 0, 737, 738, 7, 16, 0, 0, 738, 98, 1, 0, 0, 0, 739, 740, 7, 17, 0, 0, 740, 100, 1, 0, 0, 0, 741, 742, 7, 18, 0, 0, 742, 102, 1, 0, 0, 0, 743, 744, 7, 19, 0, 0, 744, 104, 1, 0, 0, 0, 745, 746, 7, 20, 0, 0, 746, 106, 1, 0, 0, 0, 747, 748, 7, 21, 0, 0, 748, 108, 1, 0, 0, 0, 749, 750, 7, 22, 0, 0, 750, 110, 1, 0, 0, 0, 751, 752, 7, 23, 0, 0, 752, 112, 1, 0, 0, 0, 753, 754, 7, 24, 0, 0, 754, 114, 1, 0, 0, 0, 755, 756, 7, 25, 0, 0, 756, 116, 1, 0, 0, 0, 757, 758, 7, 26, 0, 0, 758, 118, 1, 0, 0, 0, 759, 760, 7, 27, 0, 0, 760, 120, 1, 0, 0, 0, 761, 762, 7, 28, 0, 0, 762, 122, 1, 0, 0, 0, 763, 764, 7, 29, 0, 0, 764, 124, 1, 0, 0, 0, 765, 766, 7, 30, 0, 0, 766, 126, 1, 0, 0, 0, 767, 768, 7, 31, 0, 0, 768, 128, 1, 0, 0, 0, 769, 770, 7, 32, 0, 0, 770, 130, 1, 0, 0, 0, 771, 772, 7, 2, 0, 0, 772, 132, 1, 0, 0, 0, 773, 782, 5, 48, 0, 0, 774, 778, 7, 33, 0, 0, 775, 777, 7, 2, 0, 0, 776, 775, 1, 0, 0, 0, 777, 780, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 778, 779, 1, 0, 0, 0, 779, 782, 1, 0, 0, 0, 780, 778, 1, 0, 0, 0, 781, 773, 1, 0, 0, 0, 781, 774, 1, 0, 0, 0, 782, 134, 1, 0, 0, 0, 783, 784, 3, 95, 47, 0, 784, 785, 3, 89, 44, 0, 785, 136, 1, 0, 0, 0, 786, 787, 3, 117, 58, 0, 787, 788, 3, 93, 46, 0, 788, 789, 3, 87, 43, 0, 789, 790, 3, 105, 52, 0, 790, 138, 1, 0, 0, 0, 791, 792, 3, 87, 43, 0, 792, 793, 3, 101, 50, 0, 793, 794, 3, 115, 57, 0, 794, 795, 3, 87, 43, 0, 795, 140, 1, 0, 0, 0, 796, 797, 3, 81, 40, 0, 797, 798, 3, 107, 53, 0, 798, 799, 3, 107, 53, 0, 799, 800, 3, 101, 50, 0, 800, 801, 3, 87, 43, 0, 801, 802, 3, 79, 39, 0, 802, 803, 3, 105, 52, 0, 803, 142, 1, 0, 0, 0, 804, 805, 3, 95, 47, 0, 805, 806, 5, 56, 0, 0, 806, 144, 1, 0, 0, 0, 807, 808, 3, 95, 47, 0, 808, 809, 5, 49, 0, 0, 809, 810, 5, 54, 0, 0, 810, 146, 1, 0, 0, 0, 811, 812, 3, 95, 47, 0, 812, 813, 5, 51, 0, 0, 813, 814, 5, 50, 0, 0, 814, 148, 1, 0, 0, 0, 815, 816, 3, 95, 47, 0, 816, 817, 5, 54, 0, 0, 817, 818, 5, 52, 0, 0, 818, 150, 1, 0, 0, 0, 819, 820, 3, 89, 44, 0, 820, 821, 3, 109, 54, 0, 821, 822, 5, 51, 0, 0, 822, 823, 5, 50, 0, 0, 823, 152, 1, 0, 0, 0, 824, 825, 3, 89, 44, 0, 825, 826, 3, 109, 54, 0, 826, 827, 5, 54, 0, 0, 827, 828, 5, 52, 0, 0, 828, 154, 1, 0, 0, 0, 829, 830, 3, 115, 57, 0, 830, 831, 3, 117, 58, 0, 831, 832, 3, 113, 56, 0, 832, 833, 3, 95, 47, 0, 833, 834, 3, 105, 52, 0, 834, 835, 3, 91, 45, 0, 835, 156, 1, 0, 0, 0, 836, 837, 3, 81, 40, 0, 837, 838, 3, 95, 47, 0, 838, 839, 3, 105, 52, 0, 839, 840, 3, 79, 39, 0, 840, 841, 3, 113, 56, 0, 841, 842, 3, 127, 63, 0, 842, 158, 1, 0, 0, 0, 843, 844, 3, 117, 58, 0, 844, 845, 3, 95, 47, 0, 845, 846, 3, 103, 51, 0, 846, 847, 3, 87, 43, 0, 847, 848, 3, 115, 57, 0, 848, 849, 3, 117, 58, 0, 849, 850, 3, 79, 39, 0, 850, 851, 3, 103, 51, 0, 851, 852, 3, 109, 54, 0, 852, 160, 1, 0, 0, 0, 853, 854, 3, 117, 58, 0, 854, 855, 3, 95, 47, 0, 855, 856, 3, 103, 51, 0, 856, 857, 3, 87, 43, 0, 857, 858, 3, 115, 57, 0, 858, 859, 3, 117, 58, 0, 859, 860, 3, 79, 39, 0, 860, 861, 3, 103, 51, 0, 861, 862, 3, 109, 54, 0, 862, 863, 5, 95, 0, 0, 863, 864, 3, 117, 58, 0, 864, 865, 3, 129, 64, 0, 865, 162, 1, 0, 0, 0, 866, 867, 3, 85, 42, 0, 867, 868, 3, 79, 39, 0, 868, 869, 3, 117, 58, 0, 869, 870, 3, 87, 43, 0, 870, 164, 1, 0, 0, 0, 871, 872, 3, 117, 58, 0, 872, 873, 3, 95, 47, 0, 873, 874, 3, 103, 51, 0, 874, 875, 3, 87, 43, 0, 875, 166, 1, 0, 0, 0, 876, 877, 3, 95, 47, 0, 877, 878, 3, 105, 52, 0, 878, 879, 3, 117, 58, 0, 879, 880, 3, 87, 43, 0, 880, 881, 3, 113, 56, 0, 881, 882, 3, 121, 60, 0, 882, 883, 3, 79, 39, 0, 883, 884, 3, 101, 50, 0, 884, 885, 5, 95, 0, 0, 885, 886, 3, 127, 63, 0, 886, 887, 3, 87, 43, 0, 887, 888, 3, 79, 39, 0, 888, 889, 3, 113, 56, 0, 889, 168, 1, 0, 0, 0, 890, 891, 3, 95, 47, 0, 891, 892, 3, 105, 52, 0, 892, 893, 3, 117, 58, 0, 893, 894, 3, 87, 43, 0, 894, 895, 3, 113, 56, 0, 895, 896, 3, 121, 60, 0, 896, 897, 3, 79, 39, 0, 897, 898, 3, 101, 50, 0, 898, 899, 5, 95, 0, 0, 899, 900, 3, 85, 42, 0, 900, 901, 3, 79, 39, 0, 901, 902, 3, 127, 63, 0, 902, 170, 1, 0, 0, 0, 903, 904, 3, 119, 59, 0, 904, 905, 3, 119, 59, 0, 905, 906, 3, 95, 47, 0, 906, 907, 3, 85, 42, 0, 907, 172, 1, 0, 0, 0, 908, 909, 3, 85, 42, 0, 909, 910, 3, 87, 43, 0, 910, 911, 3, 83, 41, 0, 911, 912, 3, 95, 47, 0, 912, 913, 3, 103, 51, 0, 913, 914, 3, 79, 39, 0, 914, 915, 3, 101, 50, 0, 915, 174, 1, 0, 0, 0, 916, 917, 3, 109, 54, 0, 917, 918, 3, 113, 56, 0, 918, 919, 3, 87, 43, 0, 919, 920, 3, 83, 41, 0, 920, 921, 3, 95, 47, 0, 921, 922, 3, 115, 57, 0, 922, 923, 3, 95, 47, 0, 923, 924, 3, 107, 53, 0, 924, 925, 3, 105, 52, 0, 925, 926, 5, 95, 0, 0, 926, 927, 3, 117, 58, 0, 927, 928, 3, 95, 47, 0, 928, 929, 3, 103, 51, 0, 929, 930, 3, 87, 43, 0, 930, 931, 3, 115, 57, 0, 931, 932, 3, 117, 58, 0, 932, 933, 3, 79, 39, 0, 933, 934, 3, 103, 51, 0, 934, 935, 3, 109, 54, 0, 935, 176, 1, 0, 0, 0, 936, 937, 3, 109, 54, 0, 937, 938, 3, 113, 56, 0, 938, 939, 3, 87, 43, 0, 939, 940, 3, 83, 41, 0, 940, 941, 3, 95, 47, 0, 941, 942, 3, 115, 57, 0, 942, 943, 3, 95, 47, 0, 943, 944, 3, 107, 53, 0, 944, 945, 3, 105, 52, 0, 945, 946, 5, 95, 0, 0, 946, 947, 3, 117, 58, 0, 947, 948, 3, 95, 47, 0, 948, 949, 3, 103, 51, 0, 949, 950, 3, 87, 43, 0, 950, 951, 3, 115, 57, 0, 951, 952, 3, 117, 58, 0, 952, 953, 3, 79, 39, 0, 953, 954, 3, 103, 51, 0, 954, 955, 3, 109, 54, 0, 955, 956, 5, 95, 0, 0, 956, 957, 3, 117, 58, 0, 957, 958, 3, 129, 64, 0, 958, 178, 1, 0, 0, 0, 959, 960, 3, 89, 44, 0, 960, 961, 3, 95, 47, 0, 961, 962, 3, 125, 62, 0, 962, 963, 3, 87, 43, 0, 963, 964, 3, 85, 42, 0, 964, 965, 3, 83, 41, 0, 965, 966, 3, 93, 46, 0, 966, 967, 3, 79, 39, 0, 967, 968, 3, 113, 56, 0, 968, 180, 1, 0, 0, 0, 969, 970, 3, 121, 60, 0, 970, 971, 3, 79, 39, 0, 971, 972, 3, 113, 56, 0, 972, 973, 3, 83, 41, 0, 973, 974, 3, 93, 46, 0, 974, 975, 3, 79, 39, 0, 975, 976, 3, 113, 56, 0, 976, 182, 1, 0, 0, 0, 977, 978, 3, 89, 44, 0, 978, 979, 3, 95, 47, 0, 979, 980, 3, 125, 62, 0, 980, 981, 3, 87, 43, 0, 981, 982, 3, 85, 42, 0, 982, 983, 3, 81, 40, 0, 983, 984, 3, 95, 47, 0, 984, 985, 3, 105, 52, 0, 985, 986, 3, 79, 39, 0, 986, 987, 3, 113, 56, 0, 987, 988, 3, 127, 63, 0, 988, 184, 1, 0, 0, 0, 989, 990, 3, 115, 57, 0, 990, 991, 3, 117, 58, 0, 991, 992, 3, 113, 56, 0, 992, 993, 3, 119, 59, 0, 993, 994, 3, 83, 41, 0, 994, 995, 3, 117, 58, 0, 995, 186, 1, 0, 0, 0, 996, 997, 3, 105, 52, 0, 997, 998, 3, 115, 57, 0, 998, 999, 3, 117, 58, 0, 999, 1000, 3, 113, 56, 0, 1000, 1001, 3, 119, 59, 0, 1001, 1002, 3, 83, 41, 0, 1002, 1003, 3, 117, 58, 0, 1003, 188, 1, 0, 0, 0, 1004, 1005, 3, 101, 50, 0, 1005, 1006, 3, 95, 47, 0, 1006, 1007, 3, 115, 57, 0, 1007, 1008, 3, 117, 58, 0, 1008, 190, 1, 0, 0, 0, 1009, 1010, 3, 103, 51, 0, 1010, 1011, 3, 79, 39, 0, 1011, 1012, 3, 109, 54, 0, 1012, 192, 1, 0, 0, 0, 1013, 1014, 3, 79, 39, 0, 1014, 1015, 3, 105, 52, 0, 1015, 1016, 3, 127, 63, 0, 1016, 194, 1, 0, 0, 0, 1017, 1018, 3, 119, 59, 0, 1018, 1019, 5, 33, 0, 0, 1019, 196, 1, 0, 0, 0, 1020, 1021, 3, 81, 40, 0, 1021, 1022, 3, 107, 53, 0, 1022, 1023, 3, 107, 53, 0, 1023, 1024, 3, 101, 50, 0, 1024, 198, 1, 0, 0, 0, 1025, 1026, 3, 115, 57, 0, 1026, 1027, 3, 117, 58, 0, 1027, 1028, 3, 113, 56, 0, 1028, 200, 1, 0, 0, 0, 1029, 1030, 3, 121, 60, 0, 1030, 1031, 3, 81, 40, 0, 1031, 1032, 3, 95, 47, 0, 1032, 1033, 3, 105, 52, 0, 1033, 202, 1, 0, 0, 0, 1034, 1035, 3, 117, 58, 0, 1035, 1036, 3, 115, 57, 0, 1036, 204, 1, 0, 0, 0, 1037, 1038, 3, 117, 58, 0, 1038, 1039, 3, 115, 57, 0, 1039, 1040, 3, 117, 58, 0, 1040, 1041, 3, 129, 64, 0, 1041, 206, 1, 0, 0, 0, 1042, 1043, 3, 95, 47, 0, 1043, 1044, 3, 127, 63, 0, 1044, 1045, 3, 87, 43, 0, 1045, 1046, 3, 79, 39, 0, 1046, 1047, 3, 113, 56, 0, 1047, 208, 1, 0, 0, 0, 1048, 1049, 3, 95, 47, 0, 1049, 1050, 3, 85, 42, 0, 1050, 1051, 3, 79, 39, 0, 1051, 1052, 3, 127, 63, 0, 1052, 210, 1, 0, 0, 0, 1053, 1054, 3, 85, 42, 0, 1054, 1055, 3, 87, 43, 0, 1055, 1056, 3, 83, 41, 0, 1056, 212, 1, 0, 0, 0, 1057, 1058, 3, 109, 54, 0, 1058, 1059, 3, 117, 58, 0, 1059, 1060, 3, 115, 57, 0, 1060, 214, 1, 0, 0, 0, 1061, 1062, 3, 109, 54, 0, 1062, 1063, 3, 117, 58, 0, 1063, 1064, 3, 115, 57, 0, 1064, 1065, 3, 117, 58, 0, 1065, 1066, 3, 129, 64, 0, 1066, 216, 1, 0, 0, 0, 1067, 1068, 3, 89, 44, 0, 1068, 1069, 3, 83, 41, 0, 1069, 1070, 3, 93, 46, 0, 1070, 1071, 3, 79, 39, 0, 1071, 1072, 3, 113, 56, 0, 1072, 218, 1, 0, 0, 0, 1073, 1074, 3, 121, 60, 0, 1074, 1075, 3, 83, 41, 0, 1075, 1076, 3, 93, 46, 0, 1076, 1077, 3, 79, 39, 0, 1077, 1078, 3, 113, 56, 0, 1078, 220, 1, 0, 0, 0, 1079, 1080, 3, 89, 44, 0, 1080, 1081, 3, 81, 40, 0, 1081, 1082, 3, 95, 47, 0, 1082, 1083, 3, 105, 52, 0, 1083, 222, 1, 0, 0, 0, 1084, 1085, 5, 58, 0, 0, 1085, 1086, 5, 58, 0, 0, 1086, 224, 1, 0, 0, 0, 1087, 1091, 7, 34, 0, 0, 1088, 1090, 7, 35, 0, 0, 1089, 1088, 1, 0, 0, 0, 1090, 1093, 1, 0, 0, 0, 1091, 1089, 1, 0, 0, 0, 1091, 1092, 1, 0, 0, 0, 1092, 226, 1, 0, 0, 0, 1093, 1091, 1, 0, 0, 0, 1094, 1095, 5, 60, 0, 0, 1095, 228, 1, 0, 0, 0, 1096, 1097, 5, 62, 0, 0, 1097, 230, 1, 0, 0, 0, 1098, 1099, 5, 40, 0, 0, 1099, 232, 1, 0, 0, 0, 1100, 1101, 5, 41, 0, 0, 1101, 234, 1, 0, 0, 0, 1102, 1103, 5, 91, 0, 0, 1103, 236, 1, 0, 0, 0, 1104, 1105, 5, 93, 0, 0, 1105, 238, 1, 0, 0, 0, 1106, 1107, 5, 44, 0, 0, 1107, 240, 1, 0, 0, 0, 1108, 1109, 5, 61, 0, 0, 1109, 242, 1, 0, 0, 0, 1110, 1111, 5, 58, 0, 0, 1111, 244, 1, 0, 0, 0, 1112, 1113, 5, 63, 0, 0, 1113, 246, 1, 0, 0, 0, 1114, 1115, 5, 35, 0, 0, 1115, 248, 1, 0, 0, 0, 1116, 1117, 5, 46, 0, 0, 1117, 250, 1, 0, 0, 0, 48, 0, 282, 288, 290, 321, 325, 408, 413, 418, 424, 426, 429, 434, 440, 443, 447, 452, 454, 457, 472, 483, 509, 511, 535, 537, 551, 553, 588, 598, 607, 617, 624, 629, 634, 641, 646, 653, 658, 671, 673, 684, 696, 699, 704, 715, 778, 781, 1091, 1, 0, 1, 0] \ No newline at end of file diff --git a/tests/coverage/antlr_parser/TestFileLexer.py b/tests/coverage/antlr_parser/TestFileLexer.py deleted file mode 100644 index ddd82704b..000000000 --- a/tests/coverage/antlr_parser/TestFileLexer.py +++ /dev/null @@ -1,10066 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -# Generated from TestFileLexer.g4 by ANTLR 4.13.2 -from antlr4 import ( - ATNDeserializer, - DFA, - Lexer, - LexerATNSimulator, - PredictionContextCache, -) -import sys - -if sys.version_info[1] > 5: - from typing import TextIO -else: - from typing.io import TextIO - - -def serializedATN(): - return [ - 4, - 0, - 94, - 1118, - 6, - -1, - 2, - 0, - 7, - 0, - 2, - 1, - 7, - 1, - 2, - 2, - 7, - 2, - 2, - 3, - 7, - 3, - 2, - 4, - 7, - 4, - 2, - 5, - 7, - 5, - 2, - 6, - 7, - 6, - 2, - 7, - 7, - 7, - 2, - 8, - 7, - 8, - 2, - 9, - 7, - 9, - 2, - 10, - 7, - 10, - 2, - 11, - 7, - 11, - 2, - 12, - 7, - 12, - 2, - 13, - 7, - 13, - 2, - 14, - 7, - 14, - 2, - 15, - 7, - 15, - 2, - 16, - 7, - 16, - 2, - 17, - 7, - 17, - 2, - 18, - 7, - 18, - 2, - 19, - 7, - 19, - 2, - 20, - 7, - 20, - 2, - 21, - 7, - 21, - 2, - 22, - 7, - 22, - 2, - 23, - 7, - 23, - 2, - 24, - 7, - 24, - 2, - 25, - 7, - 25, - 2, - 26, - 7, - 26, - 2, - 27, - 7, - 27, - 2, - 28, - 7, - 28, - 2, - 29, - 7, - 29, - 2, - 30, - 7, - 30, - 2, - 31, - 7, - 31, - 2, - 32, - 7, - 32, - 2, - 33, - 7, - 33, - 2, - 34, - 7, - 34, - 2, - 35, - 7, - 35, - 2, - 36, - 7, - 36, - 2, - 37, - 7, - 37, - 2, - 38, - 7, - 38, - 2, - 39, - 7, - 39, - 2, - 40, - 7, - 40, - 2, - 41, - 7, - 41, - 2, - 42, - 7, - 42, - 2, - 43, - 7, - 43, - 2, - 44, - 7, - 44, - 2, - 45, - 7, - 45, - 2, - 46, - 7, - 46, - 2, - 47, - 7, - 47, - 2, - 48, - 7, - 48, - 2, - 49, - 7, - 49, - 2, - 50, - 7, - 50, - 2, - 51, - 7, - 51, - 2, - 52, - 7, - 52, - 2, - 53, - 7, - 53, - 2, - 54, - 7, - 54, - 2, - 55, - 7, - 55, - 2, - 56, - 7, - 56, - 2, - 57, - 7, - 57, - 2, - 58, - 7, - 58, - 2, - 59, - 7, - 59, - 2, - 60, - 7, - 60, - 2, - 61, - 7, - 61, - 2, - 62, - 7, - 62, - 2, - 63, - 7, - 63, - 2, - 64, - 7, - 64, - 2, - 65, - 7, - 65, - 2, - 66, - 7, - 66, - 2, - 67, - 7, - 67, - 2, - 68, - 7, - 68, - 2, - 69, - 7, - 69, - 2, - 70, - 7, - 70, - 2, - 71, - 7, - 71, - 2, - 72, - 7, - 72, - 2, - 73, - 7, - 73, - 2, - 74, - 7, - 74, - 2, - 75, - 7, - 75, - 2, - 76, - 7, - 76, - 2, - 77, - 7, - 77, - 2, - 78, - 7, - 78, - 2, - 79, - 7, - 79, - 2, - 80, - 7, - 80, - 2, - 81, - 7, - 81, - 2, - 82, - 7, - 82, - 2, - 83, - 7, - 83, - 2, - 84, - 7, - 84, - 2, - 85, - 7, - 85, - 2, - 86, - 7, - 86, - 2, - 87, - 7, - 87, - 2, - 88, - 7, - 88, - 2, - 89, - 7, - 89, - 2, - 90, - 7, - 90, - 2, - 91, - 7, - 91, - 2, - 92, - 7, - 92, - 2, - 93, - 7, - 93, - 2, - 94, - 7, - 94, - 2, - 95, - 7, - 95, - 2, - 96, - 7, - 96, - 2, - 97, - 7, - 97, - 2, - 98, - 7, - 98, - 2, - 99, - 7, - 99, - 2, - 100, - 7, - 100, - 2, - 101, - 7, - 101, - 2, - 102, - 7, - 102, - 2, - 103, - 7, - 103, - 2, - 104, - 7, - 104, - 2, - 105, - 7, - 105, - 2, - 106, - 7, - 106, - 2, - 107, - 7, - 107, - 2, - 108, - 7, - 108, - 2, - 109, - 7, - 109, - 2, - 110, - 7, - 110, - 2, - 111, - 7, - 111, - 2, - 112, - 7, - 112, - 2, - 113, - 7, - 113, - 2, - 114, - 7, - 114, - 2, - 115, - 7, - 115, - 2, - 116, - 7, - 116, - 2, - 117, - 7, - 117, - 2, - 118, - 7, - 118, - 2, - 119, - 7, - 119, - 2, - 120, - 7, - 120, - 2, - 121, - 7, - 121, - 2, - 122, - 7, - 122, - 2, - 123, - 7, - 123, - 2, - 124, - 7, - 124, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 0, - 1, - 1, - 1, - 1, - 4, - 1, - 281, - 8, - 1, - 11, - 1, - 12, - 1, - 282, - 1, - 1, - 1, - 1, - 4, - 1, - 287, - 8, - 1, - 11, - 1, - 12, - 1, - 288, - 3, - 1, - 291, - 8, - 1, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 3, - 1, - 3, - 1, - 3, - 1, - 3, - 5, - 3, - 320, - 8, - 3, - 10, - 3, - 12, - 3, - 323, - 9, - 3, - 1, - 3, - 3, - 3, - 326, - 8, - 3, - 1, - 3, - 1, - 3, - 1, - 4, - 1, - 4, - 1, - 4, - 1, - 4, - 1, - 4, - 1, - 4, - 1, - 4, - 1, - 4, - 1, - 4, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 6, - 1, - 6, - 1, - 6, - 1, - 6, - 1, - 6, - 1, - 6, - 1, - 6, - 1, - 6, - 1, - 6, - 1, - 7, - 1, - 7, - 1, - 7, - 1, - 7, - 1, - 7, - 1, - 7, - 1, - 7, - 1, - 7, - 1, - 7, - 1, - 8, - 1, - 8, - 1, - 8, - 1, - 8, - 1, - 8, - 1, - 8, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 10, - 1, - 10, - 1, - 10, - 1, - 10, - 1, - 10, - 1, - 10, - 1, - 10, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 12, - 1, - 12, - 1, - 12, - 1, - 12, - 1, - 13, - 3, - 13, - 409, - 8, - 13, - 1, - 13, - 1, - 13, - 1, - 14, - 3, - 14, - 414, - 8, - 14, - 1, - 14, - 4, - 14, - 417, - 8, - 14, - 11, - 14, - 12, - 14, - 418, - 1, - 14, - 1, - 14, - 4, - 14, - 423, - 8, - 14, - 11, - 14, - 12, - 14, - 424, - 3, - 14, - 427, - 8, - 14, - 1, - 15, - 3, - 15, - 430, - 8, - 15, - 1, - 15, - 4, - 15, - 433, - 8, - 15, - 11, - 15, - 12, - 15, - 434, - 1, - 15, - 1, - 15, - 5, - 15, - 439, - 8, - 15, - 10, - 15, - 12, - 15, - 442, - 9, - 15, - 3, - 15, - 444, - 8, - 15, - 1, - 15, - 1, - 15, - 3, - 15, - 448, - 8, - 15, - 1, - 15, - 4, - 15, - 451, - 8, - 15, - 11, - 15, - 12, - 15, - 452, - 3, - 15, - 455, - 8, - 15, - 1, - 15, - 3, - 15, - 458, - 8, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 3, - 15, - 473, - 8, - 15, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 16, - 3, - 16, - 484, - 8, - 16, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 18, - 1, - 18, - 1, - 18, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 4, - 19, - 508, - 8, - 19, - 11, - 19, - 12, - 19, - 509, - 3, - 19, - 512, - 8, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 4, - 20, - 534, - 8, - 20, - 11, - 20, - 12, - 20, - 535, - 3, - 20, - 538, - 8, - 20, - 1, - 20, - 1, - 20, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 4, - 21, - 550, - 8, - 21, - 11, - 21, - 12, - 21, - 551, - 3, - 21, - 554, - 8, - 21, - 1, - 21, - 1, - 21, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 23, - 1, - 23, - 1, - 24, - 1, - 24, - 1, - 25, - 1, - 25, - 1, - 26, - 1, - 26, - 1, - 27, - 1, - 27, - 1, - 28, - 1, - 28, - 1, - 29, - 1, - 29, - 1, - 30, - 1, - 30, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 3, - 31, - 589, - 8, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 3, - 31, - 599, - 8, - 31, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 3, - 32, - 608, - 8, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 3, - 32, - 618, - 8, - 32, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 3, - 33, - 625, - 8, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 3, - 33, - 630, - 8, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 3, - 33, - 635, - 8, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 3, - 33, - 642, - 8, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 3, - 33, - 647, - 8, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 3, - 33, - 654, - 8, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 3, - 33, - 659, - 8, - 33, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 35, - 1, - 35, - 1, - 35, - 1, - 35, - 1, - 35, - 1, - 35, - 5, - 35, - 672, - 8, - 35, - 10, - 35, - 12, - 35, - 675, - 9, - 35, - 1, - 35, - 1, - 35, - 1, - 36, - 1, - 36, - 1, - 36, - 1, - 36, - 5, - 36, - 683, - 8, - 36, - 10, - 36, - 12, - 36, - 686, - 9, - 36, - 1, - 36, - 1, - 36, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 4, - 37, - 695, - 8, - 37, - 11, - 37, - 12, - 37, - 696, - 1, - 37, - 3, - 37, - 700, - 8, - 37, - 1, - 37, - 5, - 37, - 703, - 8, - 37, - 10, - 37, - 12, - 37, - 706, - 9, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 38, - 4, - 38, - 714, - 8, - 38, - 11, - 38, - 12, - 38, - 715, - 1, - 38, - 1, - 38, - 1, - 39, - 1, - 39, - 1, - 40, - 1, - 40, - 1, - 41, - 1, - 41, - 1, - 42, - 1, - 42, - 1, - 43, - 1, - 43, - 1, - 44, - 1, - 44, - 1, - 45, - 1, - 45, - 1, - 46, - 1, - 46, - 1, - 47, - 1, - 47, - 1, - 48, - 1, - 48, - 1, - 49, - 1, - 49, - 1, - 50, - 1, - 50, - 1, - 51, - 1, - 51, - 1, - 52, - 1, - 52, - 1, - 53, - 1, - 53, - 1, - 54, - 1, - 54, - 1, - 55, - 1, - 55, - 1, - 56, - 1, - 56, - 1, - 57, - 1, - 57, - 1, - 58, - 1, - 58, - 1, - 59, - 1, - 59, - 1, - 60, - 1, - 60, - 1, - 61, - 1, - 61, - 1, - 62, - 1, - 62, - 1, - 63, - 1, - 63, - 1, - 64, - 1, - 64, - 1, - 65, - 1, - 65, - 1, - 66, - 1, - 66, - 1, - 66, - 5, - 66, - 777, - 8, - 66, - 10, - 66, - 12, - 66, - 780, - 9, - 66, - 3, - 66, - 782, - 8, - 66, - 1, - 67, - 1, - 67, - 1, - 67, - 1, - 68, - 1, - 68, - 1, - 68, - 1, - 68, - 1, - 68, - 1, - 69, - 1, - 69, - 1, - 69, - 1, - 69, - 1, - 69, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 70, - 1, - 71, - 1, - 71, - 1, - 71, - 1, - 72, - 1, - 72, - 1, - 72, - 1, - 72, - 1, - 73, - 1, - 73, - 1, - 73, - 1, - 73, - 1, - 74, - 1, - 74, - 1, - 74, - 1, - 74, - 1, - 75, - 1, - 75, - 1, - 75, - 1, - 75, - 1, - 75, - 1, - 76, - 1, - 76, - 1, - 76, - 1, - 76, - 1, - 76, - 1, - 77, - 1, - 77, - 1, - 77, - 1, - 77, - 1, - 77, - 1, - 77, - 1, - 77, - 1, - 78, - 1, - 78, - 1, - 78, - 1, - 78, - 1, - 78, - 1, - 78, - 1, - 78, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 79, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 80, - 1, - 81, - 1, - 81, - 1, - 81, - 1, - 81, - 1, - 81, - 1, - 82, - 1, - 82, - 1, - 82, - 1, - 82, - 1, - 82, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 83, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 84, - 1, - 85, - 1, - 85, - 1, - 85, - 1, - 85, - 1, - 85, - 1, - 86, - 1, - 86, - 1, - 86, - 1, - 86, - 1, - 86, - 1, - 86, - 1, - 86, - 1, - 86, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 87, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 88, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 89, - 1, - 90, - 1, - 90, - 1, - 90, - 1, - 90, - 1, - 90, - 1, - 90, - 1, - 90, - 1, - 90, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 91, - 1, - 92, - 1, - 92, - 1, - 92, - 1, - 92, - 1, - 92, - 1, - 92, - 1, - 92, - 1, - 93, - 1, - 93, - 1, - 93, - 1, - 93, - 1, - 93, - 1, - 93, - 1, - 93, - 1, - 93, - 1, - 94, - 1, - 94, - 1, - 94, - 1, - 94, - 1, - 94, - 1, - 95, - 1, - 95, - 1, - 95, - 1, - 95, - 1, - 96, - 1, - 96, - 1, - 96, - 1, - 96, - 1, - 97, - 1, - 97, - 1, - 97, - 1, - 98, - 1, - 98, - 1, - 98, - 1, - 98, - 1, - 98, - 1, - 99, - 1, - 99, - 1, - 99, - 1, - 99, - 1, - 100, - 1, - 100, - 1, - 100, - 1, - 100, - 1, - 100, - 1, - 101, - 1, - 101, - 1, - 101, - 1, - 102, - 1, - 102, - 1, - 102, - 1, - 102, - 1, - 102, - 1, - 103, - 1, - 103, - 1, - 103, - 1, - 103, - 1, - 103, - 1, - 103, - 1, - 104, - 1, - 104, - 1, - 104, - 1, - 104, - 1, - 104, - 1, - 105, - 1, - 105, - 1, - 105, - 1, - 105, - 1, - 106, - 1, - 106, - 1, - 106, - 1, - 106, - 1, - 107, - 1, - 107, - 1, - 107, - 1, - 107, - 1, - 107, - 1, - 107, - 1, - 108, - 1, - 108, - 1, - 108, - 1, - 108, - 1, - 108, - 1, - 108, - 1, - 109, - 1, - 109, - 1, - 109, - 1, - 109, - 1, - 109, - 1, - 109, - 1, - 110, - 1, - 110, - 1, - 110, - 1, - 110, - 1, - 110, - 1, - 111, - 1, - 111, - 1, - 111, - 1, - 112, - 1, - 112, - 5, - 112, - 1090, - 8, - 112, - 10, - 112, - 12, - 112, - 1093, - 9, - 112, - 1, - 113, - 1, - 113, - 1, - 114, - 1, - 114, - 1, - 115, - 1, - 115, - 1, - 116, - 1, - 116, - 1, - 117, - 1, - 117, - 1, - 118, - 1, - 118, - 1, - 119, - 1, - 119, - 1, - 120, - 1, - 120, - 1, - 121, - 1, - 121, - 1, - 122, - 1, - 122, - 1, - 123, - 1, - 123, - 1, - 124, - 1, - 124, - 0, - 0, - 125, - 1, - 1, - 3, - 2, - 5, - 3, - 7, - 4, - 9, - 5, - 11, - 6, - 13, - 7, - 15, - 8, - 17, - 9, - 19, - 10, - 21, - 11, - 23, - 12, - 25, - 13, - 27, - 14, - 29, - 15, - 31, - 16, - 33, - 17, - 35, - 0, - 37, - 0, - 39, - 18, - 41, - 19, - 43, - 20, - 45, - 21, - 47, - 22, - 49, - 23, - 51, - 24, - 53, - 25, - 55, - 26, - 57, - 27, - 59, - 28, - 61, - 29, - 63, - 30, - 65, - 31, - 67, - 0, - 69, - 32, - 71, - 33, - 73, - 34, - 75, - 35, - 77, - 36, - 79, - 0, - 81, - 0, - 83, - 0, - 85, - 0, - 87, - 0, - 89, - 0, - 91, - 0, - 93, - 0, - 95, - 0, - 97, - 0, - 99, - 0, - 101, - 0, - 103, - 0, - 105, - 0, - 107, - 0, - 109, - 0, - 111, - 0, - 113, - 0, - 115, - 0, - 117, - 0, - 119, - 0, - 121, - 0, - 123, - 0, - 125, - 0, - 127, - 0, - 129, - 0, - 131, - 0, - 133, - 0, - 135, - 37, - 137, - 38, - 139, - 39, - 141, - 40, - 143, - 41, - 145, - 42, - 147, - 43, - 149, - 44, - 151, - 45, - 153, - 46, - 155, - 47, - 157, - 48, - 159, - 49, - 161, - 50, - 163, - 51, - 165, - 52, - 167, - 53, - 169, - 54, - 171, - 55, - 173, - 56, - 175, - 57, - 177, - 58, - 179, - 59, - 181, - 60, - 183, - 61, - 185, - 62, - 187, - 63, - 189, - 64, - 191, - 65, - 193, - 66, - 195, - 67, - 197, - 68, - 199, - 69, - 201, - 70, - 203, - 71, - 205, - 72, - 207, - 73, - 209, - 74, - 211, - 75, - 213, - 76, - 215, - 77, - 217, - 78, - 219, - 79, - 221, - 80, - 223, - 81, - 225, - 82, - 227, - 83, - 229, - 84, - 231, - 85, - 233, - 86, - 235, - 87, - 237, - 88, - 239, - 89, - 241, - 90, - 243, - 91, - 245, - 92, - 247, - 93, - 249, - 94, - 1, - 0, - 36, - 2, - 0, - 10, - 10, - 13, - 13, - 2, - 0, - 43, - 43, - 45, - 45, - 1, - 0, - 48, - 57, - 2, - 0, - 69, - 69, - 101, - 101, - 2, - 0, - 39, - 39, - 92, - 92, - 1, - 0, - 42, - 42, - 2, - 0, - 42, - 42, - 47, - 47, - 3, - 0, - 9, - 10, - 13, - 13, - 32, - 32, - 2, - 0, - 65, - 65, - 97, - 97, - 2, - 0, - 66, - 66, - 98, - 98, - 2, - 0, - 67, - 67, - 99, - 99, - 2, - 0, - 68, - 68, - 100, - 100, - 2, - 0, - 70, - 70, - 102, - 102, - 2, - 0, - 71, - 71, - 103, - 103, - 2, - 0, - 72, - 72, - 104, - 104, - 2, - 0, - 73, - 73, - 105, - 105, - 2, - 0, - 74, - 74, - 106, - 106, - 2, - 0, - 75, - 75, - 107, - 107, - 2, - 0, - 76, - 76, - 108, - 108, - 2, - 0, - 77, - 77, - 109, - 109, - 2, - 0, - 78, - 78, - 110, - 110, - 2, - 0, - 79, - 79, - 111, - 111, - 2, - 0, - 80, - 80, - 112, - 112, - 2, - 0, - 81, - 81, - 113, - 113, - 2, - 0, - 82, - 82, - 114, - 114, - 2, - 0, - 83, - 83, - 115, - 115, - 2, - 0, - 84, - 84, - 116, - 116, - 2, - 0, - 85, - 85, - 117, - 117, - 2, - 0, - 86, - 86, - 118, - 118, - 2, - 0, - 87, - 87, - 119, - 119, - 2, - 0, - 88, - 88, - 120, - 120, - 2, - 0, - 89, - 89, - 121, - 121, - 2, - 0, - 90, - 90, - 122, - 122, - 1, - 0, - 49, - 57, - 3, - 0, - 65, - 90, - 95, - 95, - 97, - 122, - 4, - 0, - 48, - 57, - 65, - 90, - 95, - 95, - 97, - 122, - 1139, - 0, - 1, - 1, - 0, - 0, - 0, - 0, - 3, - 1, - 0, - 0, - 0, - 0, - 5, - 1, - 0, - 0, - 0, - 0, - 7, - 1, - 0, - 0, - 0, - 0, - 9, - 1, - 0, - 0, - 0, - 0, - 11, - 1, - 0, - 0, - 0, - 0, - 13, - 1, - 0, - 0, - 0, - 0, - 15, - 1, - 0, - 0, - 0, - 0, - 17, - 1, - 0, - 0, - 0, - 0, - 19, - 1, - 0, - 0, - 0, - 0, - 21, - 1, - 0, - 0, - 0, - 0, - 23, - 1, - 0, - 0, - 0, - 0, - 25, - 1, - 0, - 0, - 0, - 0, - 27, - 1, - 0, - 0, - 0, - 0, - 29, - 1, - 0, - 0, - 0, - 0, - 31, - 1, - 0, - 0, - 0, - 0, - 33, - 1, - 0, - 0, - 0, - 0, - 39, - 1, - 0, - 0, - 0, - 0, - 41, - 1, - 0, - 0, - 0, - 0, - 43, - 1, - 0, - 0, - 0, - 0, - 45, - 1, - 0, - 0, - 0, - 0, - 47, - 1, - 0, - 0, - 0, - 0, - 49, - 1, - 0, - 0, - 0, - 0, - 51, - 1, - 0, - 0, - 0, - 0, - 53, - 1, - 0, - 0, - 0, - 0, - 55, - 1, - 0, - 0, - 0, - 0, - 57, - 1, - 0, - 0, - 0, - 0, - 59, - 1, - 0, - 0, - 0, - 0, - 61, - 1, - 0, - 0, - 0, - 0, - 63, - 1, - 0, - 0, - 0, - 0, - 65, - 1, - 0, - 0, - 0, - 0, - 69, - 1, - 0, - 0, - 0, - 0, - 71, - 1, - 0, - 0, - 0, - 0, - 73, - 1, - 0, - 0, - 0, - 0, - 75, - 1, - 0, - 0, - 0, - 0, - 77, - 1, - 0, - 0, - 0, - 0, - 135, - 1, - 0, - 0, - 0, - 0, - 137, - 1, - 0, - 0, - 0, - 0, - 139, - 1, - 0, - 0, - 0, - 0, - 141, - 1, - 0, - 0, - 0, - 0, - 143, - 1, - 0, - 0, - 0, - 0, - 145, - 1, - 0, - 0, - 0, - 0, - 147, - 1, - 0, - 0, - 0, - 0, - 149, - 1, - 0, - 0, - 0, - 0, - 151, - 1, - 0, - 0, - 0, - 0, - 153, - 1, - 0, - 0, - 0, - 0, - 155, - 1, - 0, - 0, - 0, - 0, - 157, - 1, - 0, - 0, - 0, - 0, - 159, - 1, - 0, - 0, - 0, - 0, - 161, - 1, - 0, - 0, - 0, - 0, - 163, - 1, - 0, - 0, - 0, - 0, - 165, - 1, - 0, - 0, - 0, - 0, - 167, - 1, - 0, - 0, - 0, - 0, - 169, - 1, - 0, - 0, - 0, - 0, - 171, - 1, - 0, - 0, - 0, - 0, - 173, - 1, - 0, - 0, - 0, - 0, - 175, - 1, - 0, - 0, - 0, - 0, - 177, - 1, - 0, - 0, - 0, - 0, - 179, - 1, - 0, - 0, - 0, - 0, - 181, - 1, - 0, - 0, - 0, - 0, - 183, - 1, - 0, - 0, - 0, - 0, - 185, - 1, - 0, - 0, - 0, - 0, - 187, - 1, - 0, - 0, - 0, - 0, - 189, - 1, - 0, - 0, - 0, - 0, - 191, - 1, - 0, - 0, - 0, - 0, - 193, - 1, - 0, - 0, - 0, - 0, - 195, - 1, - 0, - 0, - 0, - 0, - 197, - 1, - 0, - 0, - 0, - 0, - 199, - 1, - 0, - 0, - 0, - 0, - 201, - 1, - 0, - 0, - 0, - 0, - 203, - 1, - 0, - 0, - 0, - 0, - 205, - 1, - 0, - 0, - 0, - 0, - 207, - 1, - 0, - 0, - 0, - 0, - 209, - 1, - 0, - 0, - 0, - 0, - 211, - 1, - 0, - 0, - 0, - 0, - 213, - 1, - 0, - 0, - 0, - 0, - 215, - 1, - 0, - 0, - 0, - 0, - 217, - 1, - 0, - 0, - 0, - 0, - 219, - 1, - 0, - 0, - 0, - 0, - 221, - 1, - 0, - 0, - 0, - 0, - 223, - 1, - 0, - 0, - 0, - 0, - 225, - 1, - 0, - 0, - 0, - 0, - 227, - 1, - 0, - 0, - 0, - 0, - 229, - 1, - 0, - 0, - 0, - 0, - 231, - 1, - 0, - 0, - 0, - 0, - 233, - 1, - 0, - 0, - 0, - 0, - 235, - 1, - 0, - 0, - 0, - 0, - 237, - 1, - 0, - 0, - 0, - 0, - 239, - 1, - 0, - 0, - 0, - 0, - 241, - 1, - 0, - 0, - 0, - 0, - 243, - 1, - 0, - 0, - 0, - 0, - 245, - 1, - 0, - 0, - 0, - 0, - 247, - 1, - 0, - 0, - 0, - 0, - 249, - 1, - 0, - 0, - 0, - 1, - 251, - 1, - 0, - 0, - 0, - 3, - 278, - 1, - 0, - 0, - 0, - 5, - 292, - 1, - 0, - 0, - 0, - 7, - 315, - 1, - 0, - 0, - 0, - 9, - 329, - 1, - 0, - 0, - 0, - 11, - 338, - 1, - 0, - 0, - 0, - 13, - 351, - 1, - 0, - 0, - 0, - 15, - 360, - 1, - 0, - 0, - 0, - 17, - 369, - 1, - 0, - 0, - 0, - 19, - 375, - 1, - 0, - 0, - 0, - 21, - 384, - 1, - 0, - 0, - 0, - 23, - 391, - 1, - 0, - 0, - 0, - 25, - 403, - 1, - 0, - 0, - 0, - 27, - 408, - 1, - 0, - 0, - 0, - 29, - 413, - 1, - 0, - 0, - 0, - 31, - 472, - 1, - 0, - 0, - 0, - 33, - 483, - 1, - 0, - 0, - 0, - 35, - 485, - 1, - 0, - 0, - 0, - 37, - 490, - 1, - 0, - 0, - 0, - 39, - 493, - 1, - 0, - 0, - 0, - 41, - 519, - 1, - 0, - 0, - 0, - 43, - 541, - 1, - 0, - 0, - 0, - 45, - 557, - 1, - 0, - 0, - 0, - 47, - 565, - 1, - 0, - 0, - 0, - 49, - 567, - 1, - 0, - 0, - 0, - 51, - 569, - 1, - 0, - 0, - 0, - 53, - 571, - 1, - 0, - 0, - 0, - 55, - 573, - 1, - 0, - 0, - 0, - 57, - 575, - 1, - 0, - 0, - 0, - 59, - 577, - 1, - 0, - 0, - 0, - 61, - 579, - 1, - 0, - 0, - 0, - 63, - 598, - 1, - 0, - 0, - 0, - 65, - 617, - 1, - 0, - 0, - 0, - 67, - 658, - 1, - 0, - 0, - 0, - 69, - 660, - 1, - 0, - 0, - 0, - 71, - 665, - 1, - 0, - 0, - 0, - 73, - 678, - 1, - 0, - 0, - 0, - 75, - 689, - 1, - 0, - 0, - 0, - 77, - 713, - 1, - 0, - 0, - 0, - 79, - 719, - 1, - 0, - 0, - 0, - 81, - 721, - 1, - 0, - 0, - 0, - 83, - 723, - 1, - 0, - 0, - 0, - 85, - 725, - 1, - 0, - 0, - 0, - 87, - 727, - 1, - 0, - 0, - 0, - 89, - 729, - 1, - 0, - 0, - 0, - 91, - 731, - 1, - 0, - 0, - 0, - 93, - 733, - 1, - 0, - 0, - 0, - 95, - 735, - 1, - 0, - 0, - 0, - 97, - 737, - 1, - 0, - 0, - 0, - 99, - 739, - 1, - 0, - 0, - 0, - 101, - 741, - 1, - 0, - 0, - 0, - 103, - 743, - 1, - 0, - 0, - 0, - 105, - 745, - 1, - 0, - 0, - 0, - 107, - 747, - 1, - 0, - 0, - 0, - 109, - 749, - 1, - 0, - 0, - 0, - 111, - 751, - 1, - 0, - 0, - 0, - 113, - 753, - 1, - 0, - 0, - 0, - 115, - 755, - 1, - 0, - 0, - 0, - 117, - 757, - 1, - 0, - 0, - 0, - 119, - 759, - 1, - 0, - 0, - 0, - 121, - 761, - 1, - 0, - 0, - 0, - 123, - 763, - 1, - 0, - 0, - 0, - 125, - 765, - 1, - 0, - 0, - 0, - 127, - 767, - 1, - 0, - 0, - 0, - 129, - 769, - 1, - 0, - 0, - 0, - 131, - 771, - 1, - 0, - 0, - 0, - 133, - 781, - 1, - 0, - 0, - 0, - 135, - 783, - 1, - 0, - 0, - 0, - 137, - 786, - 1, - 0, - 0, - 0, - 139, - 791, - 1, - 0, - 0, - 0, - 141, - 796, - 1, - 0, - 0, - 0, - 143, - 804, - 1, - 0, - 0, - 0, - 145, - 807, - 1, - 0, - 0, - 0, - 147, - 811, - 1, - 0, - 0, - 0, - 149, - 815, - 1, - 0, - 0, - 0, - 151, - 819, - 1, - 0, - 0, - 0, - 153, - 824, - 1, - 0, - 0, - 0, - 155, - 829, - 1, - 0, - 0, - 0, - 157, - 836, - 1, - 0, - 0, - 0, - 159, - 843, - 1, - 0, - 0, - 0, - 161, - 853, - 1, - 0, - 0, - 0, - 163, - 866, - 1, - 0, - 0, - 0, - 165, - 871, - 1, - 0, - 0, - 0, - 167, - 876, - 1, - 0, - 0, - 0, - 169, - 890, - 1, - 0, - 0, - 0, - 171, - 903, - 1, - 0, - 0, - 0, - 173, - 908, - 1, - 0, - 0, - 0, - 175, - 916, - 1, - 0, - 0, - 0, - 177, - 936, - 1, - 0, - 0, - 0, - 179, - 959, - 1, - 0, - 0, - 0, - 181, - 969, - 1, - 0, - 0, - 0, - 183, - 977, - 1, - 0, - 0, - 0, - 185, - 989, - 1, - 0, - 0, - 0, - 187, - 996, - 1, - 0, - 0, - 0, - 189, - 1004, - 1, - 0, - 0, - 0, - 191, - 1009, - 1, - 0, - 0, - 0, - 193, - 1013, - 1, - 0, - 0, - 0, - 195, - 1017, - 1, - 0, - 0, - 0, - 197, - 1020, - 1, - 0, - 0, - 0, - 199, - 1025, - 1, - 0, - 0, - 0, - 201, - 1029, - 1, - 0, - 0, - 0, - 203, - 1034, - 1, - 0, - 0, - 0, - 205, - 1037, - 1, - 0, - 0, - 0, - 207, - 1042, - 1, - 0, - 0, - 0, - 209, - 1048, - 1, - 0, - 0, - 0, - 211, - 1053, - 1, - 0, - 0, - 0, - 213, - 1057, - 1, - 0, - 0, - 0, - 215, - 1061, - 1, - 0, - 0, - 0, - 217, - 1067, - 1, - 0, - 0, - 0, - 219, - 1073, - 1, - 0, - 0, - 0, - 221, - 1079, - 1, - 0, - 0, - 0, - 223, - 1084, - 1, - 0, - 0, - 0, - 225, - 1087, - 1, - 0, - 0, - 0, - 227, - 1094, - 1, - 0, - 0, - 0, - 229, - 1096, - 1, - 0, - 0, - 0, - 231, - 1098, - 1, - 0, - 0, - 0, - 233, - 1100, - 1, - 0, - 0, - 0, - 235, - 1102, - 1, - 0, - 0, - 0, - 237, - 1104, - 1, - 0, - 0, - 0, - 239, - 1106, - 1, - 0, - 0, - 0, - 241, - 1108, - 1, - 0, - 0, - 0, - 243, - 1110, - 1, - 0, - 0, - 0, - 245, - 1112, - 1, - 0, - 0, - 0, - 247, - 1114, - 1, - 0, - 0, - 0, - 249, - 1116, - 1, - 0, - 0, - 0, - 251, - 252, - 5, - 35, - 0, - 0, - 252, - 253, - 5, - 35, - 0, - 0, - 253, - 254, - 5, - 35, - 0, - 0, - 254, - 255, - 5, - 32, - 0, - 0, - 255, - 256, - 5, - 83, - 0, - 0, - 256, - 257, - 5, - 85, - 0, - 0, - 257, - 258, - 5, - 66, - 0, - 0, - 258, - 259, - 5, - 83, - 0, - 0, - 259, - 260, - 5, - 84, - 0, - 0, - 260, - 261, - 5, - 82, - 0, - 0, - 261, - 262, - 5, - 65, - 0, - 0, - 262, - 263, - 5, - 73, - 0, - 0, - 263, - 264, - 5, - 84, - 0, - 0, - 264, - 265, - 5, - 95, - 0, - 0, - 265, - 266, - 5, - 83, - 0, - 0, - 266, - 267, - 5, - 67, - 0, - 0, - 267, - 268, - 5, - 65, - 0, - 0, - 268, - 269, - 5, - 76, - 0, - 0, - 269, - 270, - 5, - 65, - 0, - 0, - 270, - 271, - 5, - 82, - 0, - 0, - 271, - 272, - 5, - 95, - 0, - 0, - 272, - 273, - 5, - 84, - 0, - 0, - 273, - 274, - 5, - 69, - 0, - 0, - 274, - 275, - 5, - 83, - 0, - 0, - 275, - 276, - 5, - 84, - 0, - 0, - 276, - 277, - 5, - 58, - 0, - 0, - 277, - 2, - 1, - 0, - 0, - 0, - 278, - 280, - 5, - 118, - 0, - 0, - 279, - 281, - 3, - 131, - 65, - 0, - 280, - 279, - 1, - 0, - 0, - 0, - 281, - 282, - 1, - 0, - 0, - 0, - 282, - 280, - 1, - 0, - 0, - 0, - 282, - 283, - 1, - 0, - 0, - 0, - 283, - 290, - 1, - 0, - 0, - 0, - 284, - 286, - 5, - 46, - 0, - 0, - 285, - 287, - 3, - 131, - 65, - 0, - 286, - 285, - 1, - 0, - 0, - 0, - 287, - 288, - 1, - 0, - 0, - 0, - 288, - 286, - 1, - 0, - 0, - 0, - 288, - 289, - 1, - 0, - 0, - 0, - 289, - 291, - 1, - 0, - 0, - 0, - 290, - 284, - 1, - 0, - 0, - 0, - 290, - 291, - 1, - 0, - 0, - 0, - 291, - 4, - 1, - 0, - 0, - 0, - 292, - 293, - 5, - 35, - 0, - 0, - 293, - 294, - 5, - 35, - 0, - 0, - 294, - 295, - 5, - 35, - 0, - 0, - 295, - 296, - 5, - 32, - 0, - 0, - 296, - 297, - 5, - 83, - 0, - 0, - 297, - 298, - 5, - 85, - 0, - 0, - 298, - 299, - 5, - 66, - 0, - 0, - 299, - 300, - 5, - 83, - 0, - 0, - 300, - 301, - 5, - 84, - 0, - 0, - 301, - 302, - 5, - 82, - 0, - 0, - 302, - 303, - 5, - 65, - 0, - 0, - 303, - 304, - 5, - 73, - 0, - 0, - 304, - 305, - 5, - 84, - 0, - 0, - 305, - 306, - 5, - 95, - 0, - 0, - 306, - 307, - 5, - 73, - 0, - 0, - 307, - 308, - 5, - 78, - 0, - 0, - 308, - 309, - 5, - 67, - 0, - 0, - 309, - 310, - 5, - 76, - 0, - 0, - 310, - 311, - 5, - 85, - 0, - 0, - 311, - 312, - 5, - 68, - 0, - 0, - 312, - 313, - 5, - 69, - 0, - 0, - 313, - 314, - 5, - 58, - 0, - 0, - 314, - 6, - 1, - 0, - 0, - 0, - 315, - 316, - 5, - 35, - 0, - 0, - 316, - 317, - 5, - 32, - 0, - 0, - 317, - 321, - 1, - 0, - 0, - 0, - 318, - 320, - 8, - 0, - 0, - 0, - 319, - 318, - 1, - 0, - 0, - 0, - 320, - 323, - 1, - 0, - 0, - 0, - 321, - 319, - 1, - 0, - 0, - 0, - 321, - 322, - 1, - 0, - 0, - 0, - 322, - 325, - 1, - 0, - 0, - 0, - 323, - 321, - 1, - 0, - 0, - 0, - 324, - 326, - 5, - 13, - 0, - 0, - 325, - 324, - 1, - 0, - 0, - 0, - 325, - 326, - 1, - 0, - 0, - 0, - 326, - 327, - 1, - 0, - 0, - 0, - 327, - 328, - 5, - 10, - 0, - 0, - 328, - 8, - 1, - 0, - 0, - 0, - 329, - 330, - 5, - 60, - 0, - 0, - 330, - 331, - 5, - 33, - 0, - 0, - 331, - 332, - 5, - 69, - 0, - 0, - 332, - 333, - 5, - 82, - 0, - 0, - 333, - 334, - 5, - 82, - 0, - 0, - 334, - 335, - 5, - 79, - 0, - 0, - 335, - 336, - 5, - 82, - 0, - 0, - 336, - 337, - 5, - 62, - 0, - 0, - 337, - 10, - 1, - 0, - 0, - 0, - 338, - 339, - 5, - 60, - 0, - 0, - 339, - 340, - 5, - 33, - 0, - 0, - 340, - 341, - 5, - 85, - 0, - 0, - 341, - 342, - 5, - 78, - 0, - 0, - 342, - 343, - 5, - 68, - 0, - 0, - 343, - 344, - 5, - 69, - 0, - 0, - 344, - 345, - 5, - 70, - 0, - 0, - 345, - 346, - 5, - 73, - 0, - 0, - 346, - 347, - 5, - 78, - 0, - 0, - 347, - 348, - 5, - 69, - 0, - 0, - 348, - 349, - 5, - 68, - 0, - 0, - 349, - 350, - 5, - 62, - 0, - 0, - 350, - 12, - 1, - 0, - 0, - 0, - 351, - 352, - 5, - 111, - 0, - 0, - 352, - 353, - 5, - 118, - 0, - 0, - 353, - 354, - 5, - 101, - 0, - 0, - 354, - 355, - 5, - 114, - 0, - 0, - 355, - 356, - 5, - 108, - 0, - 0, - 356, - 357, - 5, - 102, - 0, - 0, - 357, - 358, - 5, - 111, - 0, - 0, - 358, - 359, - 5, - 119, - 0, - 0, - 359, - 14, - 1, - 0, - 0, - 0, - 360, - 361, - 5, - 114, - 0, - 0, - 361, - 362, - 5, - 111, - 0, - 0, - 362, - 363, - 5, - 117, - 0, - 0, - 363, - 364, - 5, - 110, - 0, - 0, - 364, - 365, - 5, - 100, - 0, - 0, - 365, - 366, - 5, - 105, - 0, - 0, - 366, - 367, - 5, - 110, - 0, - 0, - 367, - 368, - 5, - 103, - 0, - 0, - 368, - 16, - 1, - 0, - 0, - 0, - 369, - 370, - 5, - 69, - 0, - 0, - 370, - 371, - 5, - 82, - 0, - 0, - 371, - 372, - 5, - 82, - 0, - 0, - 372, - 373, - 5, - 79, - 0, - 0, - 373, - 374, - 5, - 82, - 0, - 0, - 374, - 18, - 1, - 0, - 0, - 0, - 375, - 376, - 5, - 83, - 0, - 0, - 376, - 377, - 5, - 65, - 0, - 0, - 377, - 378, - 5, - 84, - 0, - 0, - 378, - 379, - 5, - 85, - 0, - 0, - 379, - 380, - 5, - 82, - 0, - 0, - 380, - 381, - 5, - 65, - 0, - 0, - 381, - 382, - 5, - 84, - 0, - 0, - 382, - 383, - 5, - 69, - 0, - 0, - 383, - 20, - 1, - 0, - 0, - 0, - 384, - 385, - 5, - 83, - 0, - 0, - 385, - 386, - 5, - 73, - 0, - 0, - 386, - 387, - 5, - 76, - 0, - 0, - 387, - 388, - 5, - 69, - 0, - 0, - 388, - 389, - 5, - 78, - 0, - 0, - 389, - 390, - 5, - 84, - 0, - 0, - 390, - 22, - 1, - 0, - 0, - 0, - 391, - 392, - 5, - 84, - 0, - 0, - 392, - 393, - 5, - 73, - 0, - 0, - 393, - 394, - 5, - 69, - 0, - 0, - 394, - 395, - 5, - 95, - 0, - 0, - 395, - 396, - 5, - 84, - 0, - 0, - 396, - 397, - 5, - 79, - 0, - 0, - 397, - 398, - 5, - 95, - 0, - 0, - 398, - 399, - 5, - 69, - 0, - 0, - 399, - 400, - 5, - 86, - 0, - 0, - 400, - 401, - 5, - 69, - 0, - 0, - 401, - 402, - 5, - 78, - 0, - 0, - 402, - 24, - 1, - 0, - 0, - 0, - 403, - 404, - 5, - 78, - 0, - 0, - 404, - 405, - 5, - 65, - 0, - 0, - 405, - 406, - 5, - 78, - 0, - 0, - 406, - 26, - 1, - 0, - 0, - 0, - 407, - 409, - 7, - 1, - 0, - 0, - 408, - 407, - 1, - 0, - 0, - 0, - 408, - 409, - 1, - 0, - 0, - 0, - 409, - 410, - 1, - 0, - 0, - 0, - 410, - 411, - 3, - 133, - 66, - 0, - 411, - 28, - 1, - 0, - 0, - 0, - 412, - 414, - 7, - 1, - 0, - 0, - 413, - 412, - 1, - 0, - 0, - 0, - 413, - 414, - 1, - 0, - 0, - 0, - 414, - 416, - 1, - 0, - 0, - 0, - 415, - 417, - 7, - 2, - 0, - 0, - 416, - 415, - 1, - 0, - 0, - 0, - 417, - 418, - 1, - 0, - 0, - 0, - 418, - 416, - 1, - 0, - 0, - 0, - 418, - 419, - 1, - 0, - 0, - 0, - 419, - 426, - 1, - 0, - 0, - 0, - 420, - 422, - 5, - 46, - 0, - 0, - 421, - 423, - 7, - 2, - 0, - 0, - 422, - 421, - 1, - 0, - 0, - 0, - 423, - 424, - 1, - 0, - 0, - 0, - 424, - 422, - 1, - 0, - 0, - 0, - 424, - 425, - 1, - 0, - 0, - 0, - 425, - 427, - 1, - 0, - 0, - 0, - 426, - 420, - 1, - 0, - 0, - 0, - 426, - 427, - 1, - 0, - 0, - 0, - 427, - 30, - 1, - 0, - 0, - 0, - 428, - 430, - 7, - 1, - 0, - 0, - 429, - 428, - 1, - 0, - 0, - 0, - 429, - 430, - 1, - 0, - 0, - 0, - 430, - 432, - 1, - 0, - 0, - 0, - 431, - 433, - 7, - 2, - 0, - 0, - 432, - 431, - 1, - 0, - 0, - 0, - 433, - 434, - 1, - 0, - 0, - 0, - 434, - 432, - 1, - 0, - 0, - 0, - 434, - 435, - 1, - 0, - 0, - 0, - 435, - 443, - 1, - 0, - 0, - 0, - 436, - 440, - 5, - 46, - 0, - 0, - 437, - 439, - 7, - 2, - 0, - 0, - 438, - 437, - 1, - 0, - 0, - 0, - 439, - 442, - 1, - 0, - 0, - 0, - 440, - 438, - 1, - 0, - 0, - 0, - 440, - 441, - 1, - 0, - 0, - 0, - 441, - 444, - 1, - 0, - 0, - 0, - 442, - 440, - 1, - 0, - 0, - 0, - 443, - 436, - 1, - 0, - 0, - 0, - 443, - 444, - 1, - 0, - 0, - 0, - 444, - 454, - 1, - 0, - 0, - 0, - 445, - 447, - 7, - 3, - 0, - 0, - 446, - 448, - 7, - 1, - 0, - 0, - 447, - 446, - 1, - 0, - 0, - 0, - 447, - 448, - 1, - 0, - 0, - 0, - 448, - 450, - 1, - 0, - 0, - 0, - 449, - 451, - 7, - 2, - 0, - 0, - 450, - 449, - 1, - 0, - 0, - 0, - 451, - 452, - 1, - 0, - 0, - 0, - 452, - 450, - 1, - 0, - 0, - 0, - 452, - 453, - 1, - 0, - 0, - 0, - 453, - 455, - 1, - 0, - 0, - 0, - 454, - 445, - 1, - 0, - 0, - 0, - 454, - 455, - 1, - 0, - 0, - 0, - 455, - 473, - 1, - 0, - 0, - 0, - 456, - 458, - 7, - 1, - 0, - 0, - 457, - 456, - 1, - 0, - 0, - 0, - 457, - 458, - 1, - 0, - 0, - 0, - 458, - 459, - 1, - 0, - 0, - 0, - 459, - 460, - 5, - 105, - 0, - 0, - 460, - 461, - 5, - 110, - 0, - 0, - 461, - 473, - 5, - 102, - 0, - 0, - 462, - 463, - 5, - 110, - 0, - 0, - 463, - 464, - 5, - 97, - 0, - 0, - 464, - 473, - 5, - 110, - 0, - 0, - 465, - 466, - 5, - 78, - 0, - 0, - 466, - 467, - 5, - 97, - 0, - 0, - 467, - 473, - 5, - 78, - 0, - 0, - 468, - 469, - 5, - 115, - 0, - 0, - 469, - 470, - 5, - 110, - 0, - 0, - 470, - 471, - 5, - 97, - 0, - 0, - 471, - 473, - 5, - 110, - 0, - 0, - 472, - 429, - 1, - 0, - 0, - 0, - 472, - 457, - 1, - 0, - 0, - 0, - 472, - 462, - 1, - 0, - 0, - 0, - 472, - 465, - 1, - 0, - 0, - 0, - 472, - 468, - 1, - 0, - 0, - 0, - 473, - 32, - 1, - 0, - 0, - 0, - 474, - 475, - 5, - 116, - 0, - 0, - 475, - 476, - 5, - 114, - 0, - 0, - 476, - 477, - 5, - 117, - 0, - 0, - 477, - 484, - 5, - 101, - 0, - 0, - 478, - 479, - 5, - 102, - 0, - 0, - 479, - 480, - 5, - 97, - 0, - 0, - 480, - 481, - 5, - 108, - 0, - 0, - 481, - 482, - 5, - 115, - 0, - 0, - 482, - 484, - 5, - 101, - 0, - 0, - 483, - 474, - 1, - 0, - 0, - 0, - 483, - 478, - 1, - 0, - 0, - 0, - 484, - 34, - 1, - 0, - 0, - 0, - 485, - 486, - 7, - 2, - 0, - 0, - 486, - 487, - 7, - 2, - 0, - 0, - 487, - 488, - 7, - 2, - 0, - 0, - 488, - 489, - 7, - 2, - 0, - 0, - 489, - 36, - 1, - 0, - 0, - 0, - 490, - 491, - 7, - 2, - 0, - 0, - 491, - 492, - 7, - 2, - 0, - 0, - 492, - 38, - 1, - 0, - 0, - 0, - 493, - 494, - 5, - 39, - 0, - 0, - 494, - 495, - 3, - 35, - 17, - 0, - 495, - 496, - 5, - 45, - 0, - 0, - 496, - 497, - 3, - 37, - 18, - 0, - 497, - 498, - 5, - 45, - 0, - 0, - 498, - 499, - 3, - 37, - 18, - 0, - 499, - 500, - 5, - 84, - 0, - 0, - 500, - 501, - 3, - 37, - 18, - 0, - 501, - 502, - 5, - 58, - 0, - 0, - 502, - 503, - 3, - 37, - 18, - 0, - 503, - 504, - 5, - 58, - 0, - 0, - 504, - 511, - 3, - 37, - 18, - 0, - 505, - 507, - 5, - 46, - 0, - 0, - 506, - 508, - 7, - 2, - 0, - 0, - 507, - 506, - 1, - 0, - 0, - 0, - 508, - 509, - 1, - 0, - 0, - 0, - 509, - 507, - 1, - 0, - 0, - 0, - 509, - 510, - 1, - 0, - 0, - 0, - 510, - 512, - 1, - 0, - 0, - 0, - 511, - 505, - 1, - 0, - 0, - 0, - 511, - 512, - 1, - 0, - 0, - 0, - 512, - 513, - 1, - 0, - 0, - 0, - 513, - 514, - 7, - 1, - 0, - 0, - 514, - 515, - 3, - 37, - 18, - 0, - 515, - 516, - 5, - 58, - 0, - 0, - 516, - 517, - 3, - 37, - 18, - 0, - 517, - 518, - 5, - 39, - 0, - 0, - 518, - 40, - 1, - 0, - 0, - 0, - 519, - 520, - 5, - 39, - 0, - 0, - 520, - 521, - 3, - 35, - 17, - 0, - 521, - 522, - 5, - 45, - 0, - 0, - 522, - 523, - 3, - 37, - 18, - 0, - 523, - 524, - 5, - 45, - 0, - 0, - 524, - 525, - 3, - 37, - 18, - 0, - 525, - 526, - 5, - 84, - 0, - 0, - 526, - 527, - 3, - 37, - 18, - 0, - 527, - 528, - 5, - 58, - 0, - 0, - 528, - 529, - 3, - 37, - 18, - 0, - 529, - 530, - 5, - 58, - 0, - 0, - 530, - 537, - 3, - 37, - 18, - 0, - 531, - 533, - 5, - 46, - 0, - 0, - 532, - 534, - 7, - 2, - 0, - 0, - 533, - 532, - 1, - 0, - 0, - 0, - 534, - 535, - 1, - 0, - 0, - 0, - 535, - 533, - 1, - 0, - 0, - 0, - 535, - 536, - 1, - 0, - 0, - 0, - 536, - 538, - 1, - 0, - 0, - 0, - 537, - 531, - 1, - 0, - 0, - 0, - 537, - 538, - 1, - 0, - 0, - 0, - 538, - 539, - 1, - 0, - 0, - 0, - 539, - 540, - 5, - 39, - 0, - 0, - 540, - 42, - 1, - 0, - 0, - 0, - 541, - 542, - 5, - 39, - 0, - 0, - 542, - 543, - 3, - 37, - 18, - 0, - 543, - 544, - 5, - 58, - 0, - 0, - 544, - 545, - 3, - 37, - 18, - 0, - 545, - 546, - 5, - 58, - 0, - 0, - 546, - 553, - 3, - 37, - 18, - 0, - 547, - 549, - 5, - 46, - 0, - 0, - 548, - 550, - 7, - 2, - 0, - 0, - 549, - 548, - 1, - 0, - 0, - 0, - 550, - 551, - 1, - 0, - 0, - 0, - 551, - 549, - 1, - 0, - 0, - 0, - 551, - 552, - 1, - 0, - 0, - 0, - 552, - 554, - 1, - 0, - 0, - 0, - 553, - 547, - 1, - 0, - 0, - 0, - 553, - 554, - 1, - 0, - 0, - 0, - 554, - 555, - 1, - 0, - 0, - 0, - 555, - 556, - 5, - 39, - 0, - 0, - 556, - 44, - 1, - 0, - 0, - 0, - 557, - 558, - 5, - 39, - 0, - 0, - 558, - 559, - 3, - 35, - 17, - 0, - 559, - 560, - 5, - 45, - 0, - 0, - 560, - 561, - 3, - 37, - 18, - 0, - 561, - 562, - 5, - 45, - 0, - 0, - 562, - 563, - 3, - 37, - 18, - 0, - 563, - 564, - 5, - 39, - 0, - 0, - 564, - 46, - 1, - 0, - 0, - 0, - 565, - 566, - 5, - 80, - 0, - 0, - 566, - 48, - 1, - 0, - 0, - 0, - 567, - 568, - 5, - 84, - 0, - 0, - 568, - 50, - 1, - 0, - 0, - 0, - 569, - 570, - 5, - 89, - 0, - 0, - 570, - 52, - 1, - 0, - 0, - 0, - 571, - 572, - 5, - 77, - 0, - 0, - 572, - 54, - 1, - 0, - 0, - 0, - 573, - 574, - 5, - 68, - 0, - 0, - 574, - 56, - 1, - 0, - 0, - 0, - 575, - 576, - 5, - 72, - 0, - 0, - 576, - 58, - 1, - 0, - 0, - 0, - 577, - 578, - 5, - 83, - 0, - 0, - 578, - 60, - 1, - 0, - 0, - 0, - 579, - 580, - 5, - 70, - 0, - 0, - 580, - 62, - 1, - 0, - 0, - 0, - 581, - 582, - 5, - 39, - 0, - 0, - 582, - 583, - 3, - 47, - 23, - 0, - 583, - 584, - 3, - 27, - 13, - 0, - 584, - 588, - 3, - 51, - 25, - 0, - 585, - 586, - 3, - 27, - 13, - 0, - 586, - 587, - 3, - 53, - 26, - 0, - 587, - 589, - 1, - 0, - 0, - 0, - 588, - 585, - 1, - 0, - 0, - 0, - 588, - 589, - 1, - 0, - 0, - 0, - 589, - 590, - 1, - 0, - 0, - 0, - 590, - 591, - 5, - 39, - 0, - 0, - 591, - 599, - 1, - 0, - 0, - 0, - 592, - 593, - 5, - 39, - 0, - 0, - 593, - 594, - 3, - 47, - 23, - 0, - 594, - 595, - 3, - 27, - 13, - 0, - 595, - 596, - 3, - 53, - 26, - 0, - 596, - 597, - 5, - 39, - 0, - 0, - 597, - 599, - 1, - 0, - 0, - 0, - 598, - 581, - 1, - 0, - 0, - 0, - 598, - 592, - 1, - 0, - 0, - 0, - 599, - 64, - 1, - 0, - 0, - 0, - 600, - 601, - 5, - 39, - 0, - 0, - 601, - 602, - 3, - 47, - 23, - 0, - 602, - 603, - 3, - 27, - 13, - 0, - 603, - 607, - 3, - 55, - 27, - 0, - 604, - 605, - 3, - 49, - 24, - 0, - 605, - 606, - 3, - 67, - 33, - 0, - 606, - 608, - 1, - 0, - 0, - 0, - 607, - 604, - 1, - 0, - 0, - 0, - 607, - 608, - 1, - 0, - 0, - 0, - 608, - 609, - 1, - 0, - 0, - 0, - 609, - 610, - 5, - 39, - 0, - 0, - 610, - 618, - 1, - 0, - 0, - 0, - 611, - 612, - 5, - 39, - 0, - 0, - 612, - 613, - 3, - 47, - 23, - 0, - 613, - 614, - 3, - 49, - 24, - 0, - 614, - 615, - 3, - 67, - 33, - 0, - 615, - 616, - 5, - 39, - 0, - 0, - 616, - 618, - 1, - 0, - 0, - 0, - 617, - 600, - 1, - 0, - 0, - 0, - 617, - 611, - 1, - 0, - 0, - 0, - 618, - 66, - 1, - 0, - 0, - 0, - 619, - 620, - 3, - 27, - 13, - 0, - 620, - 624, - 3, - 57, - 28, - 0, - 621, - 622, - 3, - 27, - 13, - 0, - 622, - 623, - 3, - 53, - 26, - 0, - 623, - 625, - 1, - 0, - 0, - 0, - 624, - 621, - 1, - 0, - 0, - 0, - 624, - 625, - 1, - 0, - 0, - 0, - 625, - 629, - 1, - 0, - 0, - 0, - 626, - 627, - 3, - 27, - 13, - 0, - 627, - 628, - 3, - 59, - 29, - 0, - 628, - 630, - 1, - 0, - 0, - 0, - 629, - 626, - 1, - 0, - 0, - 0, - 629, - 630, - 1, - 0, - 0, - 0, - 630, - 634, - 1, - 0, - 0, - 0, - 631, - 632, - 3, - 27, - 13, - 0, - 632, - 633, - 3, - 61, - 30, - 0, - 633, - 635, - 1, - 0, - 0, - 0, - 634, - 631, - 1, - 0, - 0, - 0, - 634, - 635, - 1, - 0, - 0, - 0, - 635, - 659, - 1, - 0, - 0, - 0, - 636, - 637, - 3, - 27, - 13, - 0, - 637, - 641, - 3, - 53, - 26, - 0, - 638, - 639, - 3, - 27, - 13, - 0, - 639, - 640, - 3, - 59, - 29, - 0, - 640, - 642, - 1, - 0, - 0, - 0, - 641, - 638, - 1, - 0, - 0, - 0, - 641, - 642, - 1, - 0, - 0, - 0, - 642, - 646, - 1, - 0, - 0, - 0, - 643, - 644, - 3, - 27, - 13, - 0, - 644, - 645, - 3, - 61, - 30, - 0, - 645, - 647, - 1, - 0, - 0, - 0, - 646, - 643, - 1, - 0, - 0, - 0, - 646, - 647, - 1, - 0, - 0, - 0, - 647, - 659, - 1, - 0, - 0, - 0, - 648, - 649, - 3, - 27, - 13, - 0, - 649, - 653, - 3, - 59, - 29, - 0, - 650, - 651, - 3, - 27, - 13, - 0, - 651, - 652, - 3, - 61, - 30, - 0, - 652, - 654, - 1, - 0, - 0, - 0, - 653, - 650, - 1, - 0, - 0, - 0, - 653, - 654, - 1, - 0, - 0, - 0, - 654, - 659, - 1, - 0, - 0, - 0, - 655, - 656, - 3, - 27, - 13, - 0, - 656, - 657, - 3, - 61, - 30, - 0, - 657, - 659, - 1, - 0, - 0, - 0, - 658, - 619, - 1, - 0, - 0, - 0, - 658, - 636, - 1, - 0, - 0, - 0, - 658, - 648, - 1, - 0, - 0, - 0, - 658, - 655, - 1, - 0, - 0, - 0, - 659, - 68, - 1, - 0, - 0, - 0, - 660, - 661, - 5, - 110, - 0, - 0, - 661, - 662, - 5, - 117, - 0, - 0, - 662, - 663, - 5, - 108, - 0, - 0, - 663, - 664, - 5, - 108, - 0, - 0, - 664, - 70, - 1, - 0, - 0, - 0, - 665, - 673, - 5, - 39, - 0, - 0, - 666, - 667, - 5, - 92, - 0, - 0, - 667, - 672, - 9, - 0, - 0, - 0, - 668, - 669, - 5, - 39, - 0, - 0, - 669, - 672, - 5, - 39, - 0, - 0, - 670, - 672, - 8, - 4, - 0, - 0, - 671, - 666, - 1, - 0, - 0, - 0, - 671, - 668, - 1, - 0, - 0, - 0, - 671, - 670, - 1, - 0, - 0, - 0, - 672, - 675, - 1, - 0, - 0, - 0, - 673, - 671, - 1, - 0, - 0, - 0, - 673, - 674, - 1, - 0, - 0, - 0, - 674, - 676, - 1, - 0, - 0, - 0, - 675, - 673, - 1, - 0, - 0, - 0, - 676, - 677, - 5, - 39, - 0, - 0, - 677, - 72, - 1, - 0, - 0, - 0, - 678, - 679, - 5, - 47, - 0, - 0, - 679, - 680, - 5, - 47, - 0, - 0, - 680, - 684, - 1, - 0, - 0, - 0, - 681, - 683, - 8, - 0, - 0, - 0, - 682, - 681, - 1, - 0, - 0, - 0, - 683, - 686, - 1, - 0, - 0, - 0, - 684, - 682, - 1, - 0, - 0, - 0, - 684, - 685, - 1, - 0, - 0, - 0, - 685, - 687, - 1, - 0, - 0, - 0, - 686, - 684, - 1, - 0, - 0, - 0, - 687, - 688, - 6, - 36, - 0, - 0, - 688, - 74, - 1, - 0, - 0, - 0, - 689, - 690, - 5, - 47, - 0, - 0, - 690, - 691, - 5, - 42, - 0, - 0, - 691, - 699, - 1, - 0, - 0, - 0, - 692, - 700, - 8, - 5, - 0, - 0, - 693, - 695, - 5, - 42, - 0, - 0, - 694, - 693, - 1, - 0, - 0, - 0, - 695, - 696, - 1, - 0, - 0, - 0, - 696, - 694, - 1, - 0, - 0, - 0, - 696, - 697, - 1, - 0, - 0, - 0, - 697, - 698, - 1, - 0, - 0, - 0, - 698, - 700, - 8, - 6, - 0, - 0, - 699, - 692, - 1, - 0, - 0, - 0, - 699, - 694, - 1, - 0, - 0, - 0, - 700, - 704, - 1, - 0, - 0, - 0, - 701, - 703, - 5, - 42, - 0, - 0, - 702, - 701, - 1, - 0, - 0, - 0, - 703, - 706, - 1, - 0, - 0, - 0, - 704, - 702, - 1, - 0, - 0, - 0, - 704, - 705, - 1, - 0, - 0, - 0, - 705, - 707, - 1, - 0, - 0, - 0, - 706, - 704, - 1, - 0, - 0, - 0, - 707, - 708, - 5, - 42, - 0, - 0, - 708, - 709, - 5, - 47, - 0, - 0, - 709, - 710, - 1, - 0, - 0, - 0, - 710, - 711, - 6, - 37, - 0, - 0, - 711, - 76, - 1, - 0, - 0, - 0, - 712, - 714, - 7, - 7, - 0, - 0, - 713, - 712, - 1, - 0, - 0, - 0, - 714, - 715, - 1, - 0, - 0, - 0, - 715, - 713, - 1, - 0, - 0, - 0, - 715, - 716, - 1, - 0, - 0, - 0, - 716, - 717, - 1, - 0, - 0, - 0, - 717, - 718, - 6, - 38, - 0, - 0, - 718, - 78, - 1, - 0, - 0, - 0, - 719, - 720, - 7, - 8, - 0, - 0, - 720, - 80, - 1, - 0, - 0, - 0, - 721, - 722, - 7, - 9, - 0, - 0, - 722, - 82, - 1, - 0, - 0, - 0, - 723, - 724, - 7, - 10, - 0, - 0, - 724, - 84, - 1, - 0, - 0, - 0, - 725, - 726, - 7, - 11, - 0, - 0, - 726, - 86, - 1, - 0, - 0, - 0, - 727, - 728, - 7, - 3, - 0, - 0, - 728, - 88, - 1, - 0, - 0, - 0, - 729, - 730, - 7, - 12, - 0, - 0, - 730, - 90, - 1, - 0, - 0, - 0, - 731, - 732, - 7, - 13, - 0, - 0, - 732, - 92, - 1, - 0, - 0, - 0, - 733, - 734, - 7, - 14, - 0, - 0, - 734, - 94, - 1, - 0, - 0, - 0, - 735, - 736, - 7, - 15, - 0, - 0, - 736, - 96, - 1, - 0, - 0, - 0, - 737, - 738, - 7, - 16, - 0, - 0, - 738, - 98, - 1, - 0, - 0, - 0, - 739, - 740, - 7, - 17, - 0, - 0, - 740, - 100, - 1, - 0, - 0, - 0, - 741, - 742, - 7, - 18, - 0, - 0, - 742, - 102, - 1, - 0, - 0, - 0, - 743, - 744, - 7, - 19, - 0, - 0, - 744, - 104, - 1, - 0, - 0, - 0, - 745, - 746, - 7, - 20, - 0, - 0, - 746, - 106, - 1, - 0, - 0, - 0, - 747, - 748, - 7, - 21, - 0, - 0, - 748, - 108, - 1, - 0, - 0, - 0, - 749, - 750, - 7, - 22, - 0, - 0, - 750, - 110, - 1, - 0, - 0, - 0, - 751, - 752, - 7, - 23, - 0, - 0, - 752, - 112, - 1, - 0, - 0, - 0, - 753, - 754, - 7, - 24, - 0, - 0, - 754, - 114, - 1, - 0, - 0, - 0, - 755, - 756, - 7, - 25, - 0, - 0, - 756, - 116, - 1, - 0, - 0, - 0, - 757, - 758, - 7, - 26, - 0, - 0, - 758, - 118, - 1, - 0, - 0, - 0, - 759, - 760, - 7, - 27, - 0, - 0, - 760, - 120, - 1, - 0, - 0, - 0, - 761, - 762, - 7, - 28, - 0, - 0, - 762, - 122, - 1, - 0, - 0, - 0, - 763, - 764, - 7, - 29, - 0, - 0, - 764, - 124, - 1, - 0, - 0, - 0, - 765, - 766, - 7, - 30, - 0, - 0, - 766, - 126, - 1, - 0, - 0, - 0, - 767, - 768, - 7, - 31, - 0, - 0, - 768, - 128, - 1, - 0, - 0, - 0, - 769, - 770, - 7, - 32, - 0, - 0, - 770, - 130, - 1, - 0, - 0, - 0, - 771, - 772, - 7, - 2, - 0, - 0, - 772, - 132, - 1, - 0, - 0, - 0, - 773, - 782, - 5, - 48, - 0, - 0, - 774, - 778, - 7, - 33, - 0, - 0, - 775, - 777, - 7, - 2, - 0, - 0, - 776, - 775, - 1, - 0, - 0, - 0, - 777, - 780, - 1, - 0, - 0, - 0, - 778, - 776, - 1, - 0, - 0, - 0, - 778, - 779, - 1, - 0, - 0, - 0, - 779, - 782, - 1, - 0, - 0, - 0, - 780, - 778, - 1, - 0, - 0, - 0, - 781, - 773, - 1, - 0, - 0, - 0, - 781, - 774, - 1, - 0, - 0, - 0, - 782, - 134, - 1, - 0, - 0, - 0, - 783, - 784, - 3, - 95, - 47, - 0, - 784, - 785, - 3, - 89, - 44, - 0, - 785, - 136, - 1, - 0, - 0, - 0, - 786, - 787, - 3, - 117, - 58, - 0, - 787, - 788, - 3, - 93, - 46, - 0, - 788, - 789, - 3, - 87, - 43, - 0, - 789, - 790, - 3, - 105, - 52, - 0, - 790, - 138, - 1, - 0, - 0, - 0, - 791, - 792, - 3, - 87, - 43, - 0, - 792, - 793, - 3, - 101, - 50, - 0, - 793, - 794, - 3, - 115, - 57, - 0, - 794, - 795, - 3, - 87, - 43, - 0, - 795, - 140, - 1, - 0, - 0, - 0, - 796, - 797, - 3, - 81, - 40, - 0, - 797, - 798, - 3, - 107, - 53, - 0, - 798, - 799, - 3, - 107, - 53, - 0, - 799, - 800, - 3, - 101, - 50, - 0, - 800, - 801, - 3, - 87, - 43, - 0, - 801, - 802, - 3, - 79, - 39, - 0, - 802, - 803, - 3, - 105, - 52, - 0, - 803, - 142, - 1, - 0, - 0, - 0, - 804, - 805, - 3, - 95, - 47, - 0, - 805, - 806, - 5, - 56, - 0, - 0, - 806, - 144, - 1, - 0, - 0, - 0, - 807, - 808, - 3, - 95, - 47, - 0, - 808, - 809, - 5, - 49, - 0, - 0, - 809, - 810, - 5, - 54, - 0, - 0, - 810, - 146, - 1, - 0, - 0, - 0, - 811, - 812, - 3, - 95, - 47, - 0, - 812, - 813, - 5, - 51, - 0, - 0, - 813, - 814, - 5, - 50, - 0, - 0, - 814, - 148, - 1, - 0, - 0, - 0, - 815, - 816, - 3, - 95, - 47, - 0, - 816, - 817, - 5, - 54, - 0, - 0, - 817, - 818, - 5, - 52, - 0, - 0, - 818, - 150, - 1, - 0, - 0, - 0, - 819, - 820, - 3, - 89, - 44, - 0, - 820, - 821, - 3, - 109, - 54, - 0, - 821, - 822, - 5, - 51, - 0, - 0, - 822, - 823, - 5, - 50, - 0, - 0, - 823, - 152, - 1, - 0, - 0, - 0, - 824, - 825, - 3, - 89, - 44, - 0, - 825, - 826, - 3, - 109, - 54, - 0, - 826, - 827, - 5, - 54, - 0, - 0, - 827, - 828, - 5, - 52, - 0, - 0, - 828, - 154, - 1, - 0, - 0, - 0, - 829, - 830, - 3, - 115, - 57, - 0, - 830, - 831, - 3, - 117, - 58, - 0, - 831, - 832, - 3, - 113, - 56, - 0, - 832, - 833, - 3, - 95, - 47, - 0, - 833, - 834, - 3, - 105, - 52, - 0, - 834, - 835, - 3, - 91, - 45, - 0, - 835, - 156, - 1, - 0, - 0, - 0, - 836, - 837, - 3, - 81, - 40, - 0, - 837, - 838, - 3, - 95, - 47, - 0, - 838, - 839, - 3, - 105, - 52, - 0, - 839, - 840, - 3, - 79, - 39, - 0, - 840, - 841, - 3, - 113, - 56, - 0, - 841, - 842, - 3, - 127, - 63, - 0, - 842, - 158, - 1, - 0, - 0, - 0, - 843, - 844, - 3, - 117, - 58, - 0, - 844, - 845, - 3, - 95, - 47, - 0, - 845, - 846, - 3, - 103, - 51, - 0, - 846, - 847, - 3, - 87, - 43, - 0, - 847, - 848, - 3, - 115, - 57, - 0, - 848, - 849, - 3, - 117, - 58, - 0, - 849, - 850, - 3, - 79, - 39, - 0, - 850, - 851, - 3, - 103, - 51, - 0, - 851, - 852, - 3, - 109, - 54, - 0, - 852, - 160, - 1, - 0, - 0, - 0, - 853, - 854, - 3, - 117, - 58, - 0, - 854, - 855, - 3, - 95, - 47, - 0, - 855, - 856, - 3, - 103, - 51, - 0, - 856, - 857, - 3, - 87, - 43, - 0, - 857, - 858, - 3, - 115, - 57, - 0, - 858, - 859, - 3, - 117, - 58, - 0, - 859, - 860, - 3, - 79, - 39, - 0, - 860, - 861, - 3, - 103, - 51, - 0, - 861, - 862, - 3, - 109, - 54, - 0, - 862, - 863, - 5, - 95, - 0, - 0, - 863, - 864, - 3, - 117, - 58, - 0, - 864, - 865, - 3, - 129, - 64, - 0, - 865, - 162, - 1, - 0, - 0, - 0, - 866, - 867, - 3, - 85, - 42, - 0, - 867, - 868, - 3, - 79, - 39, - 0, - 868, - 869, - 3, - 117, - 58, - 0, - 869, - 870, - 3, - 87, - 43, - 0, - 870, - 164, - 1, - 0, - 0, - 0, - 871, - 872, - 3, - 117, - 58, - 0, - 872, - 873, - 3, - 95, - 47, - 0, - 873, - 874, - 3, - 103, - 51, - 0, - 874, - 875, - 3, - 87, - 43, - 0, - 875, - 166, - 1, - 0, - 0, - 0, - 876, - 877, - 3, - 95, - 47, - 0, - 877, - 878, - 3, - 105, - 52, - 0, - 878, - 879, - 3, - 117, - 58, - 0, - 879, - 880, - 3, - 87, - 43, - 0, - 880, - 881, - 3, - 113, - 56, - 0, - 881, - 882, - 3, - 121, - 60, - 0, - 882, - 883, - 3, - 79, - 39, - 0, - 883, - 884, - 3, - 101, - 50, - 0, - 884, - 885, - 5, - 95, - 0, - 0, - 885, - 886, - 3, - 127, - 63, - 0, - 886, - 887, - 3, - 87, - 43, - 0, - 887, - 888, - 3, - 79, - 39, - 0, - 888, - 889, - 3, - 113, - 56, - 0, - 889, - 168, - 1, - 0, - 0, - 0, - 890, - 891, - 3, - 95, - 47, - 0, - 891, - 892, - 3, - 105, - 52, - 0, - 892, - 893, - 3, - 117, - 58, - 0, - 893, - 894, - 3, - 87, - 43, - 0, - 894, - 895, - 3, - 113, - 56, - 0, - 895, - 896, - 3, - 121, - 60, - 0, - 896, - 897, - 3, - 79, - 39, - 0, - 897, - 898, - 3, - 101, - 50, - 0, - 898, - 899, - 5, - 95, - 0, - 0, - 899, - 900, - 3, - 85, - 42, - 0, - 900, - 901, - 3, - 79, - 39, - 0, - 901, - 902, - 3, - 127, - 63, - 0, - 902, - 170, - 1, - 0, - 0, - 0, - 903, - 904, - 3, - 119, - 59, - 0, - 904, - 905, - 3, - 119, - 59, - 0, - 905, - 906, - 3, - 95, - 47, - 0, - 906, - 907, - 3, - 85, - 42, - 0, - 907, - 172, - 1, - 0, - 0, - 0, - 908, - 909, - 3, - 85, - 42, - 0, - 909, - 910, - 3, - 87, - 43, - 0, - 910, - 911, - 3, - 83, - 41, - 0, - 911, - 912, - 3, - 95, - 47, - 0, - 912, - 913, - 3, - 103, - 51, - 0, - 913, - 914, - 3, - 79, - 39, - 0, - 914, - 915, - 3, - 101, - 50, - 0, - 915, - 174, - 1, - 0, - 0, - 0, - 916, - 917, - 3, - 109, - 54, - 0, - 917, - 918, - 3, - 113, - 56, - 0, - 918, - 919, - 3, - 87, - 43, - 0, - 919, - 920, - 3, - 83, - 41, - 0, - 920, - 921, - 3, - 95, - 47, - 0, - 921, - 922, - 3, - 115, - 57, - 0, - 922, - 923, - 3, - 95, - 47, - 0, - 923, - 924, - 3, - 107, - 53, - 0, - 924, - 925, - 3, - 105, - 52, - 0, - 925, - 926, - 5, - 95, - 0, - 0, - 926, - 927, - 3, - 117, - 58, - 0, - 927, - 928, - 3, - 95, - 47, - 0, - 928, - 929, - 3, - 103, - 51, - 0, - 929, - 930, - 3, - 87, - 43, - 0, - 930, - 931, - 3, - 115, - 57, - 0, - 931, - 932, - 3, - 117, - 58, - 0, - 932, - 933, - 3, - 79, - 39, - 0, - 933, - 934, - 3, - 103, - 51, - 0, - 934, - 935, - 3, - 109, - 54, - 0, - 935, - 176, - 1, - 0, - 0, - 0, - 936, - 937, - 3, - 109, - 54, - 0, - 937, - 938, - 3, - 113, - 56, - 0, - 938, - 939, - 3, - 87, - 43, - 0, - 939, - 940, - 3, - 83, - 41, - 0, - 940, - 941, - 3, - 95, - 47, - 0, - 941, - 942, - 3, - 115, - 57, - 0, - 942, - 943, - 3, - 95, - 47, - 0, - 943, - 944, - 3, - 107, - 53, - 0, - 944, - 945, - 3, - 105, - 52, - 0, - 945, - 946, - 5, - 95, - 0, - 0, - 946, - 947, - 3, - 117, - 58, - 0, - 947, - 948, - 3, - 95, - 47, - 0, - 948, - 949, - 3, - 103, - 51, - 0, - 949, - 950, - 3, - 87, - 43, - 0, - 950, - 951, - 3, - 115, - 57, - 0, - 951, - 952, - 3, - 117, - 58, - 0, - 952, - 953, - 3, - 79, - 39, - 0, - 953, - 954, - 3, - 103, - 51, - 0, - 954, - 955, - 3, - 109, - 54, - 0, - 955, - 956, - 5, - 95, - 0, - 0, - 956, - 957, - 3, - 117, - 58, - 0, - 957, - 958, - 3, - 129, - 64, - 0, - 958, - 178, - 1, - 0, - 0, - 0, - 959, - 960, - 3, - 89, - 44, - 0, - 960, - 961, - 3, - 95, - 47, - 0, - 961, - 962, - 3, - 125, - 62, - 0, - 962, - 963, - 3, - 87, - 43, - 0, - 963, - 964, - 3, - 85, - 42, - 0, - 964, - 965, - 3, - 83, - 41, - 0, - 965, - 966, - 3, - 93, - 46, - 0, - 966, - 967, - 3, - 79, - 39, - 0, - 967, - 968, - 3, - 113, - 56, - 0, - 968, - 180, - 1, - 0, - 0, - 0, - 969, - 970, - 3, - 121, - 60, - 0, - 970, - 971, - 3, - 79, - 39, - 0, - 971, - 972, - 3, - 113, - 56, - 0, - 972, - 973, - 3, - 83, - 41, - 0, - 973, - 974, - 3, - 93, - 46, - 0, - 974, - 975, - 3, - 79, - 39, - 0, - 975, - 976, - 3, - 113, - 56, - 0, - 976, - 182, - 1, - 0, - 0, - 0, - 977, - 978, - 3, - 89, - 44, - 0, - 978, - 979, - 3, - 95, - 47, - 0, - 979, - 980, - 3, - 125, - 62, - 0, - 980, - 981, - 3, - 87, - 43, - 0, - 981, - 982, - 3, - 85, - 42, - 0, - 982, - 983, - 3, - 81, - 40, - 0, - 983, - 984, - 3, - 95, - 47, - 0, - 984, - 985, - 3, - 105, - 52, - 0, - 985, - 986, - 3, - 79, - 39, - 0, - 986, - 987, - 3, - 113, - 56, - 0, - 987, - 988, - 3, - 127, - 63, - 0, - 988, - 184, - 1, - 0, - 0, - 0, - 989, - 990, - 3, - 115, - 57, - 0, - 990, - 991, - 3, - 117, - 58, - 0, - 991, - 992, - 3, - 113, - 56, - 0, - 992, - 993, - 3, - 119, - 59, - 0, - 993, - 994, - 3, - 83, - 41, - 0, - 994, - 995, - 3, - 117, - 58, - 0, - 995, - 186, - 1, - 0, - 0, - 0, - 996, - 997, - 3, - 105, - 52, - 0, - 997, - 998, - 3, - 115, - 57, - 0, - 998, - 999, - 3, - 117, - 58, - 0, - 999, - 1000, - 3, - 113, - 56, - 0, - 1000, - 1001, - 3, - 119, - 59, - 0, - 1001, - 1002, - 3, - 83, - 41, - 0, - 1002, - 1003, - 3, - 117, - 58, - 0, - 1003, - 188, - 1, - 0, - 0, - 0, - 1004, - 1005, - 3, - 101, - 50, - 0, - 1005, - 1006, - 3, - 95, - 47, - 0, - 1006, - 1007, - 3, - 115, - 57, - 0, - 1007, - 1008, - 3, - 117, - 58, - 0, - 1008, - 190, - 1, - 0, - 0, - 0, - 1009, - 1010, - 3, - 103, - 51, - 0, - 1010, - 1011, - 3, - 79, - 39, - 0, - 1011, - 1012, - 3, - 109, - 54, - 0, - 1012, - 192, - 1, - 0, - 0, - 0, - 1013, - 1014, - 3, - 79, - 39, - 0, - 1014, - 1015, - 3, - 105, - 52, - 0, - 1015, - 1016, - 3, - 127, - 63, - 0, - 1016, - 194, - 1, - 0, - 0, - 0, - 1017, - 1018, - 3, - 119, - 59, - 0, - 1018, - 1019, - 5, - 33, - 0, - 0, - 1019, - 196, - 1, - 0, - 0, - 0, - 1020, - 1021, - 3, - 81, - 40, - 0, - 1021, - 1022, - 3, - 107, - 53, - 0, - 1022, - 1023, - 3, - 107, - 53, - 0, - 1023, - 1024, - 3, - 101, - 50, - 0, - 1024, - 198, - 1, - 0, - 0, - 0, - 1025, - 1026, - 3, - 115, - 57, - 0, - 1026, - 1027, - 3, - 117, - 58, - 0, - 1027, - 1028, - 3, - 113, - 56, - 0, - 1028, - 200, - 1, - 0, - 0, - 0, - 1029, - 1030, - 3, - 121, - 60, - 0, - 1030, - 1031, - 3, - 81, - 40, - 0, - 1031, - 1032, - 3, - 95, - 47, - 0, - 1032, - 1033, - 3, - 105, - 52, - 0, - 1033, - 202, - 1, - 0, - 0, - 0, - 1034, - 1035, - 3, - 117, - 58, - 0, - 1035, - 1036, - 3, - 115, - 57, - 0, - 1036, - 204, - 1, - 0, - 0, - 0, - 1037, - 1038, - 3, - 117, - 58, - 0, - 1038, - 1039, - 3, - 115, - 57, - 0, - 1039, - 1040, - 3, - 117, - 58, - 0, - 1040, - 1041, - 3, - 129, - 64, - 0, - 1041, - 206, - 1, - 0, - 0, - 0, - 1042, - 1043, - 3, - 95, - 47, - 0, - 1043, - 1044, - 3, - 127, - 63, - 0, - 1044, - 1045, - 3, - 87, - 43, - 0, - 1045, - 1046, - 3, - 79, - 39, - 0, - 1046, - 1047, - 3, - 113, - 56, - 0, - 1047, - 208, - 1, - 0, - 0, - 0, - 1048, - 1049, - 3, - 95, - 47, - 0, - 1049, - 1050, - 3, - 85, - 42, - 0, - 1050, - 1051, - 3, - 79, - 39, - 0, - 1051, - 1052, - 3, - 127, - 63, - 0, - 1052, - 210, - 1, - 0, - 0, - 0, - 1053, - 1054, - 3, - 85, - 42, - 0, - 1054, - 1055, - 3, - 87, - 43, - 0, - 1055, - 1056, - 3, - 83, - 41, - 0, - 1056, - 212, - 1, - 0, - 0, - 0, - 1057, - 1058, - 3, - 109, - 54, - 0, - 1058, - 1059, - 3, - 117, - 58, - 0, - 1059, - 1060, - 3, - 115, - 57, - 0, - 1060, - 214, - 1, - 0, - 0, - 0, - 1061, - 1062, - 3, - 109, - 54, - 0, - 1062, - 1063, - 3, - 117, - 58, - 0, - 1063, - 1064, - 3, - 115, - 57, - 0, - 1064, - 1065, - 3, - 117, - 58, - 0, - 1065, - 1066, - 3, - 129, - 64, - 0, - 1066, - 216, - 1, - 0, - 0, - 0, - 1067, - 1068, - 3, - 89, - 44, - 0, - 1068, - 1069, - 3, - 83, - 41, - 0, - 1069, - 1070, - 3, - 93, - 46, - 0, - 1070, - 1071, - 3, - 79, - 39, - 0, - 1071, - 1072, - 3, - 113, - 56, - 0, - 1072, - 218, - 1, - 0, - 0, - 0, - 1073, - 1074, - 3, - 121, - 60, - 0, - 1074, - 1075, - 3, - 83, - 41, - 0, - 1075, - 1076, - 3, - 93, - 46, - 0, - 1076, - 1077, - 3, - 79, - 39, - 0, - 1077, - 1078, - 3, - 113, - 56, - 0, - 1078, - 220, - 1, - 0, - 0, - 0, - 1079, - 1080, - 3, - 89, - 44, - 0, - 1080, - 1081, - 3, - 81, - 40, - 0, - 1081, - 1082, - 3, - 95, - 47, - 0, - 1082, - 1083, - 3, - 105, - 52, - 0, - 1083, - 222, - 1, - 0, - 0, - 0, - 1084, - 1085, - 5, - 58, - 0, - 0, - 1085, - 1086, - 5, - 58, - 0, - 0, - 1086, - 224, - 1, - 0, - 0, - 0, - 1087, - 1091, - 7, - 34, - 0, - 0, - 1088, - 1090, - 7, - 35, - 0, - 0, - 1089, - 1088, - 1, - 0, - 0, - 0, - 1090, - 1093, - 1, - 0, - 0, - 0, - 1091, - 1089, - 1, - 0, - 0, - 0, - 1091, - 1092, - 1, - 0, - 0, - 0, - 1092, - 226, - 1, - 0, - 0, - 0, - 1093, - 1091, - 1, - 0, - 0, - 0, - 1094, - 1095, - 5, - 60, - 0, - 0, - 1095, - 228, - 1, - 0, - 0, - 0, - 1096, - 1097, - 5, - 62, - 0, - 0, - 1097, - 230, - 1, - 0, - 0, - 0, - 1098, - 1099, - 5, - 40, - 0, - 0, - 1099, - 232, - 1, - 0, - 0, - 0, - 1100, - 1101, - 5, - 41, - 0, - 0, - 1101, - 234, - 1, - 0, - 0, - 0, - 1102, - 1103, - 5, - 91, - 0, - 0, - 1103, - 236, - 1, - 0, - 0, - 0, - 1104, - 1105, - 5, - 93, - 0, - 0, - 1105, - 238, - 1, - 0, - 0, - 0, - 1106, - 1107, - 5, - 44, - 0, - 0, - 1107, - 240, - 1, - 0, - 0, - 0, - 1108, - 1109, - 5, - 61, - 0, - 0, - 1109, - 242, - 1, - 0, - 0, - 0, - 1110, - 1111, - 5, - 58, - 0, - 0, - 1111, - 244, - 1, - 0, - 0, - 0, - 1112, - 1113, - 5, - 63, - 0, - 0, - 1113, - 246, - 1, - 0, - 0, - 0, - 1114, - 1115, - 5, - 35, - 0, - 0, - 1115, - 248, - 1, - 0, - 0, - 0, - 1116, - 1117, - 5, - 46, - 0, - 0, - 1117, - 250, - 1, - 0, - 0, - 0, - 48, - 0, - 282, - 288, - 290, - 321, - 325, - 408, - 413, - 418, - 424, - 426, - 429, - 434, - 440, - 443, - 447, - 452, - 454, - 457, - 472, - 483, - 509, - 511, - 535, - 537, - 551, - 553, - 588, - 598, - 607, - 617, - 624, - 629, - 634, - 641, - 646, - 653, - 658, - 671, - 673, - 684, - 696, - 699, - 704, - 715, - 778, - 781, - 1091, - 1, - 0, - 1, - 0, - ] - - -class TestFileLexer(Lexer): - - atn = ATNDeserializer().deserialize(serializedATN()) - - decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] - - SUBSTRAIT_SCALAR_TEST = 1 - FORMAT_VERSION = 2 - SUBSTRAIT_INCLUDE = 3 - DESCRIPTION_LINE = 4 - ERROR_RESULT = 5 - UNDEFINED_RESULT = 6 - OVERFLOW = 7 - ROUNDING = 8 - ERROR = 9 - SATURATE = 10 - SILENT = 11 - TIE_TO_EVEN = 12 - NAN = 13 - INTEGER_LITERAL = 14 - DECIMAL_LITERAL = 15 - FLOAT_LITERAL = 16 - BOOLEAN_LITERAL = 17 - TIMESTAMP_TZ_LITERAL = 18 - TIMESTAMP_LITERAL = 19 - TIME_LITERAL = 20 - DATE_LITERAL = 21 - PERIOD_PREFIX = 22 - TIME_PREFIX = 23 - YEAR_SUFFIX = 24 - M_SUFFIX = 25 - DAY_SUFFIX = 26 - HOUR_SUFFIX = 27 - SECOND_SUFFIX = 28 - FRACTIONAL_SECOND_SUFFIX = 29 - INTERVAL_YEAR_LITERAL = 30 - INTERVAL_DAY_LITERAL = 31 - NULL_LITERAL = 32 - STRING_LITERAL = 33 - LineComment = 34 - BlockComment = 35 - Whitespace = 36 - If = 37 - Then = 38 - Else = 39 - Boolean = 40 - I8 = 41 - I16 = 42 - I32 = 43 - I64 = 44 - FP32 = 45 - FP64 = 46 - String = 47 - Binary = 48 - Timestamp = 49 - TimestampTZ = 50 - Date = 51 - Time = 52 - IntervalYear = 53 - IntervalDay = 54 - UUID = 55 - Decimal = 56 - PrecisionTimestamp = 57 - PrecisionTimestampTZ = 58 - FixedChar = 59 - VarChar = 60 - FixedBinary = 61 - Struct = 62 - NStruct = 63 - List = 64 - Map = 65 - ANY = 66 - UserDefined = 67 - Bool = 68 - Str = 69 - VBin = 70 - Ts = 71 - TsTZ = 72 - IYear = 73 - IDay = 74 - Dec = 75 - PTs = 76 - PTsTZ = 77 - FChar = 78 - VChar = 79 - FBin = 80 - DOUBLE_COLON = 81 - IDENTIFIER = 82 - O_ANGLE_BRACKET = 83 - C_ANGLE_BRACKET = 84 - OPAREN = 85 - CPAREN = 86 - OBRACKET = 87 - CBRACKET = 88 - COMMA = 89 - EQ = 90 - COLON = 91 - QMARK = 92 - HASH = 93 - DOT = 94 - - channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] - - modeNames = ["DEFAULT_MODE"] - - literalNames = [ - "", - "'### SUBSTRAIT_SCALAR_TEST:'", - "'### SUBSTRAIT_INCLUDE:'", - "''", - "''", - "'overlfow'", - "'rounding'", - "'ERROR'", - "'SATURATE'", - "'SILENT'", - "'TIE_TO_EVEN'", - "'NAN'", - "'P'", - "'T'", - "'Y'", - "'M'", - "'D'", - "'H'", - "'S'", - "'F'", - "'null'", - "'::'", - "'<'", - "'>'", - "'('", - "')'", - "'['", - "']'", - "','", - "'='", - "':'", - "'?'", - "'#'", - "'.'", - ] - - symbolicNames = [ - "", - "SUBSTRAIT_SCALAR_TEST", - "FORMAT_VERSION", - "SUBSTRAIT_INCLUDE", - "DESCRIPTION_LINE", - "ERROR_RESULT", - "UNDEFINED_RESULT", - "OVERFLOW", - "ROUNDING", - "ERROR", - "SATURATE", - "SILENT", - "TIE_TO_EVEN", - "NAN", - "INTEGER_LITERAL", - "DECIMAL_LITERAL", - "FLOAT_LITERAL", - "BOOLEAN_LITERAL", - "TIMESTAMP_TZ_LITERAL", - "TIMESTAMP_LITERAL", - "TIME_LITERAL", - "DATE_LITERAL", - "PERIOD_PREFIX", - "TIME_PREFIX", - "YEAR_SUFFIX", - "M_SUFFIX", - "DAY_SUFFIX", - "HOUR_SUFFIX", - "SECOND_SUFFIX", - "FRACTIONAL_SECOND_SUFFIX", - "INTERVAL_YEAR_LITERAL", - "INTERVAL_DAY_LITERAL", - "NULL_LITERAL", - "STRING_LITERAL", - "LineComment", - "BlockComment", - "Whitespace", - "If", - "Then", - "Else", - "Boolean", - "I8", - "I16", - "I32", - "I64", - "FP32", - "FP64", - "String", - "Binary", - "Timestamp", - "TimestampTZ", - "Date", - "Time", - "IntervalYear", - "IntervalDay", - "UUID", - "Decimal", - "PrecisionTimestamp", - "PrecisionTimestampTZ", - "FixedChar", - "VarChar", - "FixedBinary", - "Struct", - "NStruct", - "List", - "Map", - "ANY", - "UserDefined", - "Bool", - "Str", - "VBin", - "Ts", - "TsTZ", - "IYear", - "IDay", - "Dec", - "PTs", - "PTsTZ", - "FChar", - "VChar", - "FBin", - "DOUBLE_COLON", - "IDENTIFIER", - "O_ANGLE_BRACKET", - "C_ANGLE_BRACKET", - "OPAREN", - "CPAREN", - "OBRACKET", - "CBRACKET", - "COMMA", - "EQ", - "COLON", - "QMARK", - "HASH", - "DOT", - ] - - ruleNames = [ - "SUBSTRAIT_SCALAR_TEST", - "FORMAT_VERSION", - "SUBSTRAIT_INCLUDE", - "DESCRIPTION_LINE", - "ERROR_RESULT", - "UNDEFINED_RESULT", - "OVERFLOW", - "ROUNDING", - "ERROR", - "SATURATE", - "SILENT", - "TIE_TO_EVEN", - "NAN", - "INTEGER_LITERAL", - "DECIMAL_LITERAL", - "FLOAT_LITERAL", - "BOOLEAN_LITERAL", - "FourDigits", - "TwoDigits", - "TIMESTAMP_TZ_LITERAL", - "TIMESTAMP_LITERAL", - "TIME_LITERAL", - "DATE_LITERAL", - "PERIOD_PREFIX", - "TIME_PREFIX", - "YEAR_SUFFIX", - "M_SUFFIX", - "DAY_SUFFIX", - "HOUR_SUFFIX", - "SECOND_SUFFIX", - "FRACTIONAL_SECOND_SUFFIX", - "INTERVAL_YEAR_LITERAL", - "INTERVAL_DAY_LITERAL", - "TIME_INTERVAL", - "NULL_LITERAL", - "STRING_LITERAL", - "LineComment", - "BlockComment", - "Whitespace", - "A", - "B", - "C", - "D", - "E", - "F", - "G", - "H", - "I", - "J", - "K", - "L", - "M", - "N", - "O", - "P", - "Q", - "R", - "S", - "T", - "U", - "V", - "W", - "X", - "Y", - "Z", - "DIGIT", - "INTEGER", - "If", - "Then", - "Else", - "Boolean", - "I8", - "I16", - "I32", - "I64", - "FP32", - "FP64", - "String", - "Binary", - "Timestamp", - "TimestampTZ", - "Date", - "Time", - "IntervalYear", - "IntervalDay", - "UUID", - "Decimal", - "PrecisionTimestamp", - "PrecisionTimestampTZ", - "FixedChar", - "VarChar", - "FixedBinary", - "Struct", - "NStruct", - "List", - "Map", - "ANY", - "UserDefined", - "Bool", - "Str", - "VBin", - "Ts", - "TsTZ", - "IYear", - "IDay", - "Dec", - "PTs", - "PTsTZ", - "FChar", - "VChar", - "FBin", - "DOUBLE_COLON", - "IDENTIFIER", - "O_ANGLE_BRACKET", - "C_ANGLE_BRACKET", - "OPAREN", - "CPAREN", - "OBRACKET", - "CBRACKET", - "COMMA", - "EQ", - "COLON", - "QMARK", - "HASH", - "DOT", - ] - - grammarFileName = "TestFileLexer.g4" - - def __init__(self, input=None, output: TextIO = sys.stdout): - super().__init__(input, output) - self.checkVersion("4.13.2") - self._interp = LexerATNSimulator( - self, self.atn, self.decisionsToDFA, PredictionContextCache() - ) - self._actions = None - self._predicates = None diff --git a/tests/coverage/antlr_parser/TestFileParser.py b/tests/coverage/antlr_parser/TestFileParser.py deleted file mode 100644 index d14a36e23..000000000 --- a/tests/coverage/antlr_parser/TestFileParser.py +++ /dev/null @@ -1,7477 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -# Generated from TestFileParser.g4 by ANTLR 4.13.2 -# encoding: utf-8 -from antlr4 import ( - ATNDeserializer, - DFA, - NoViableAltException, - ParseTreeListener, - ParseTreeVisitor, - Parser, - ParserATNSimulator, - ParserRuleContext, - PredictionContextCache, - RecognitionException, - Token, - TokenStream, -) -import sys - -if sys.version_info[1] > 5: - from typing import TextIO -else: - from typing.io import TextIO - - -def serializedATN(): - return [ - 4, - 1, - 94, - 395, - 2, - 0, - 7, - 0, - 2, - 1, - 7, - 1, - 2, - 2, - 7, - 2, - 2, - 3, - 7, - 3, - 2, - 4, - 7, - 4, - 2, - 5, - 7, - 5, - 2, - 6, - 7, - 6, - 2, - 7, - 7, - 7, - 2, - 8, - 7, - 8, - 2, - 9, - 7, - 9, - 2, - 10, - 7, - 10, - 2, - 11, - 7, - 11, - 2, - 12, - 7, - 12, - 2, - 13, - 7, - 13, - 2, - 14, - 7, - 14, - 2, - 15, - 7, - 15, - 2, - 16, - 7, - 16, - 2, - 17, - 7, - 17, - 2, - 18, - 7, - 18, - 2, - 19, - 7, - 19, - 2, - 20, - 7, - 20, - 2, - 21, - 7, - 21, - 2, - 22, - 7, - 22, - 2, - 23, - 7, - 23, - 2, - 24, - 7, - 24, - 2, - 25, - 7, - 25, - 2, - 26, - 7, - 26, - 2, - 27, - 7, - 27, - 2, - 28, - 7, - 28, - 2, - 29, - 7, - 29, - 2, - 30, - 7, - 30, - 2, - 31, - 7, - 31, - 2, - 32, - 7, - 32, - 2, - 33, - 7, - 33, - 2, - 34, - 7, - 34, - 2, - 35, - 7, - 35, - 2, - 36, - 7, - 36, - 2, - 37, - 7, - 37, - 2, - 38, - 7, - 38, - 2, - 39, - 7, - 39, - 2, - 40, - 7, - 40, - 2, - 41, - 7, - 41, - 2, - 42, - 7, - 42, - 2, - 43, - 7, - 43, - 2, - 44, - 7, - 44, - 1, - 0, - 1, - 0, - 4, - 0, - 93, - 8, - 0, - 11, - 0, - 12, - 0, - 94, - 1, - 0, - 1, - 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 2, - 1, - 2, - 1, - 2, - 1, - 3, - 1, - 3, - 1, - 3, - 1, - 3, - 5, - 3, - 109, - 8, - 3, - 10, - 3, - 12, - 3, - 112, - 9, - 3, - 1, - 4, - 1, - 4, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 3, - 5, - 124, - 8, - 5, - 1, - 5, - 1, - 5, - 1, - 5, - 1, - 6, - 1, - 6, - 4, - 6, - 131, - 8, - 6, - 11, - 6, - 12, - 6, - 132, - 1, - 7, - 1, - 7, - 1, - 7, - 5, - 7, - 138, - 8, - 7, - 10, - 7, - 12, - 7, - 141, - 9, - 7, - 1, - 8, - 1, - 8, - 3, - 8, - 145, - 8, - 8, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 1, - 9, - 3, - 9, - 163, - 8, - 9, - 1, - 10, - 1, - 10, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 11, - 1, - 12, - 1, - 12, - 1, - 12, - 1, - 12, - 1, - 13, - 1, - 13, - 1, - 13, - 1, - 13, - 1, - 14, - 1, - 14, - 1, - 14, - 1, - 14, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 15, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 16, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 17, - 1, - 18, - 1, - 18, - 1, - 18, - 1, - 18, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 19, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 20, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 21, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 22, - 1, - 23, - 1, - 23, - 1, - 23, - 1, - 23, - 1, - 24, - 1, - 24, - 1, - 24, - 1, - 24, - 1, - 25, - 1, - 25, - 1, - 25, - 1, - 25, - 1, - 26, - 1, - 26, - 1, - 26, - 1, - 26, - 1, - 27, - 1, - 27, - 1, - 27, - 1, - 27, - 1, - 27, - 1, - 27, - 3, - 27, - 237, - 8, - 27, - 1, - 27, - 1, - 27, - 1, - 27, - 3, - 27, - 242, - 8, - 27, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 3, - 28, - 250, - 8, - 28, - 1, - 28, - 1, - 28, - 1, - 28, - 3, - 28, - 255, - 8, - 28, - 1, - 29, - 1, - 29, - 1, - 29, - 1, - 29, - 3, - 29, - 261, - 8, - 29, - 1, - 29, - 1, - 29, - 3, - 29, - 265, - 8, - 29, - 1, - 29, - 1, - 29, - 3, - 29, - 269, - 8, - 29, - 1, - 29, - 1, - 29, - 1, - 29, - 1, - 29, - 3, - 29, - 275, - 8, - 29, - 1, - 29, - 1, - 29, - 3, - 29, - 279, - 8, - 29, - 1, - 29, - 1, - 29, - 1, - 29, - 1, - 29, - 3, - 29, - 285, - 8, - 29, - 1, - 29, - 1, - 29, - 3, - 29, - 289, - 8, - 29, - 1, - 30, - 1, - 30, - 3, - 30, - 293, - 8, - 30, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 1, - 31, - 3, - 31, - 313, - 8, - 31, - 1, - 32, - 1, - 32, - 3, - 32, - 317, - 8, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 32, - 1, - 33, - 1, - 33, - 3, - 33, - 325, - 8, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 33, - 1, - 34, - 1, - 34, - 3, - 34, - 333, - 8, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 34, - 1, - 35, - 1, - 35, - 3, - 35, - 341, - 8, - 35, - 1, - 35, - 1, - 35, - 1, - 35, - 1, - 35, - 1, - 35, - 1, - 35, - 3, - 35, - 349, - 8, - 35, - 1, - 36, - 1, - 36, - 3, - 36, - 353, - 8, - 36, - 1, - 36, - 1, - 36, - 1, - 36, - 1, - 36, - 1, - 37, - 1, - 37, - 3, - 37, - 361, - 8, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 37, - 1, - 38, - 1, - 38, - 1, - 38, - 1, - 38, - 1, - 38, - 1, - 38, - 3, - 38, - 373, - 8, - 38, - 1, - 39, - 1, - 39, - 1, - 40, - 1, - 40, - 1, - 41, - 1, - 41, - 1, - 41, - 1, - 41, - 1, - 42, - 1, - 42, - 1, - 43, - 1, - 43, - 1, - 44, - 1, - 44, - 1, - 44, - 5, - 44, - 390, - 8, - 44, - 10, - 44, - 12, - 44, - 393, - 9, - 44, - 1, - 44, - 0, - 0, - 45, - 0, - 2, - 4, - 6, - 8, - 10, - 12, - 14, - 16, - 18, - 20, - 22, - 24, - 26, - 28, - 30, - 32, - 34, - 36, - 38, - 40, - 42, - 44, - 46, - 48, - 50, - 52, - 54, - 56, - 58, - 60, - 62, - 64, - 66, - 68, - 70, - 72, - 74, - 76, - 78, - 80, - 82, - 84, - 86, - 88, - 0, - 4, - 1, - 0, - 14, - 16, - 1, - 0, - 5, - 6, - 2, - 0, - 7, - 8, - 82, - 82, - 1, - 0, - 9, - 13, - 413, - 0, - 90, - 1, - 0, - 0, - 0, - 2, - 98, - 1, - 0, - 0, - 0, - 4, - 101, - 1, - 0, - 0, - 0, - 6, - 104, - 1, - 0, - 0, - 0, - 8, - 113, - 1, - 0, - 0, - 0, - 10, - 115, - 1, - 0, - 0, - 0, - 12, - 128, - 1, - 0, - 0, - 0, - 14, - 134, - 1, - 0, - 0, - 0, - 16, - 144, - 1, - 0, - 0, - 0, - 18, - 162, - 1, - 0, - 0, - 0, - 20, - 164, - 1, - 0, - 0, - 0, - 22, - 166, - 1, - 0, - 0, - 0, - 24, - 170, - 1, - 0, - 0, - 0, - 26, - 174, - 1, - 0, - 0, - 0, - 28, - 178, - 1, - 0, - 0, - 0, - 30, - 182, - 1, - 0, - 0, - 0, - 32, - 186, - 1, - 0, - 0, - 0, - 34, - 190, - 1, - 0, - 0, - 0, - 36, - 194, - 1, - 0, - 0, - 0, - 38, - 198, - 1, - 0, - 0, - 0, - 40, - 202, - 1, - 0, - 0, - 0, - 42, - 206, - 1, - 0, - 0, - 0, - 44, - 210, - 1, - 0, - 0, - 0, - 46, - 214, - 1, - 0, - 0, - 0, - 48, - 218, - 1, - 0, - 0, - 0, - 50, - 222, - 1, - 0, - 0, - 0, - 52, - 226, - 1, - 0, - 0, - 0, - 54, - 241, - 1, - 0, - 0, - 0, - 56, - 254, - 1, - 0, - 0, - 0, - 58, - 288, - 1, - 0, - 0, - 0, - 60, - 292, - 1, - 0, - 0, - 0, - 62, - 312, - 1, - 0, - 0, - 0, - 64, - 314, - 1, - 0, - 0, - 0, - 66, - 322, - 1, - 0, - 0, - 0, - 68, - 330, - 1, - 0, - 0, - 0, - 70, - 338, - 1, - 0, - 0, - 0, - 72, - 350, - 1, - 0, - 0, - 0, - 74, - 358, - 1, - 0, - 0, - 0, - 76, - 372, - 1, - 0, - 0, - 0, - 78, - 374, - 1, - 0, - 0, - 0, - 80, - 376, - 1, - 0, - 0, - 0, - 82, - 378, - 1, - 0, - 0, - 0, - 84, - 382, - 1, - 0, - 0, - 0, - 86, - 384, - 1, - 0, - 0, - 0, - 88, - 386, - 1, - 0, - 0, - 0, - 90, - 92, - 3, - 2, - 1, - 0, - 91, - 93, - 3, - 12, - 6, - 0, - 92, - 91, - 1, - 0, - 0, - 0, - 93, - 94, - 1, - 0, - 0, - 0, - 94, - 92, - 1, - 0, - 0, - 0, - 94, - 95, - 1, - 0, - 0, - 0, - 95, - 96, - 1, - 0, - 0, - 0, - 96, - 97, - 5, - 0, - 0, - 1, - 97, - 1, - 1, - 0, - 0, - 0, - 98, - 99, - 3, - 4, - 2, - 0, - 99, - 100, - 3, - 6, - 3, - 0, - 100, - 3, - 1, - 0, - 0, - 0, - 101, - 102, - 5, - 1, - 0, - 0, - 102, - 103, - 5, - 2, - 0, - 0, - 103, - 5, - 1, - 0, - 0, - 0, - 104, - 105, - 5, - 3, - 0, - 0, - 105, - 110, - 5, - 33, - 0, - 0, - 106, - 107, - 5, - 89, - 0, - 0, - 107, - 109, - 5, - 33, - 0, - 0, - 108, - 106, - 1, - 0, - 0, - 0, - 109, - 112, - 1, - 0, - 0, - 0, - 110, - 108, - 1, - 0, - 0, - 0, - 110, - 111, - 1, - 0, - 0, - 0, - 111, - 7, - 1, - 0, - 0, - 0, - 112, - 110, - 1, - 0, - 0, - 0, - 113, - 114, - 5, - 4, - 0, - 0, - 114, - 9, - 1, - 0, - 0, - 0, - 115, - 116, - 5, - 82, - 0, - 0, - 116, - 117, - 5, - 85, - 0, - 0, - 117, - 118, - 3, - 14, - 7, - 0, - 118, - 123, - 5, - 86, - 0, - 0, - 119, - 120, - 5, - 87, - 0, - 0, - 120, - 121, - 3, - 88, - 44, - 0, - 121, - 122, - 5, - 88, - 0, - 0, - 122, - 124, - 1, - 0, - 0, - 0, - 123, - 119, - 1, - 0, - 0, - 0, - 123, - 124, - 1, - 0, - 0, - 0, - 124, - 125, - 1, - 0, - 0, - 0, - 125, - 126, - 5, - 90, - 0, - 0, - 126, - 127, - 3, - 16, - 8, - 0, - 127, - 11, - 1, - 0, - 0, - 0, - 128, - 130, - 3, - 8, - 4, - 0, - 129, - 131, - 3, - 10, - 5, - 0, - 130, - 129, - 1, - 0, - 0, - 0, - 131, - 132, - 1, - 0, - 0, - 0, - 132, - 130, - 1, - 0, - 0, - 0, - 132, - 133, - 1, - 0, - 0, - 0, - 133, - 13, - 1, - 0, - 0, - 0, - 134, - 139, - 3, - 18, - 9, - 0, - 135, - 136, - 5, - 89, - 0, - 0, - 136, - 138, - 3, - 18, - 9, - 0, - 137, - 135, - 1, - 0, - 0, - 0, - 138, - 141, - 1, - 0, - 0, - 0, - 139, - 137, - 1, - 0, - 0, - 0, - 139, - 140, - 1, - 0, - 0, - 0, - 140, - 15, - 1, - 0, - 0, - 0, - 141, - 139, - 1, - 0, - 0, - 0, - 142, - 145, - 3, - 18, - 9, - 0, - 143, - 145, - 3, - 80, - 40, - 0, - 144, - 142, - 1, - 0, - 0, - 0, - 144, - 143, - 1, - 0, - 0, - 0, - 145, - 17, - 1, - 0, - 0, - 0, - 146, - 163, - 3, - 22, - 11, - 0, - 147, - 163, - 3, - 24, - 12, - 0, - 148, - 163, - 3, - 26, - 13, - 0, - 149, - 163, - 3, - 28, - 14, - 0, - 150, - 163, - 3, - 30, - 15, - 0, - 151, - 163, - 3, - 32, - 16, - 0, - 152, - 163, - 3, - 34, - 17, - 0, - 153, - 163, - 3, - 38, - 19, - 0, - 154, - 163, - 3, - 40, - 20, - 0, - 155, - 163, - 3, - 36, - 18, - 0, - 156, - 163, - 3, - 42, - 21, - 0, - 157, - 163, - 3, - 44, - 22, - 0, - 158, - 163, - 3, - 46, - 23, - 0, - 159, - 163, - 3, - 48, - 24, - 0, - 160, - 163, - 3, - 50, - 25, - 0, - 161, - 163, - 3, - 52, - 26, - 0, - 162, - 146, - 1, - 0, - 0, - 0, - 162, - 147, - 1, - 0, - 0, - 0, - 162, - 148, - 1, - 0, - 0, - 0, - 162, - 149, - 1, - 0, - 0, - 0, - 162, - 150, - 1, - 0, - 0, - 0, - 162, - 151, - 1, - 0, - 0, - 0, - 162, - 152, - 1, - 0, - 0, - 0, - 162, - 153, - 1, - 0, - 0, - 0, - 162, - 154, - 1, - 0, - 0, - 0, - 162, - 155, - 1, - 0, - 0, - 0, - 162, - 156, - 1, - 0, - 0, - 0, - 162, - 157, - 1, - 0, - 0, - 0, - 162, - 158, - 1, - 0, - 0, - 0, - 162, - 159, - 1, - 0, - 0, - 0, - 162, - 160, - 1, - 0, - 0, - 0, - 162, - 161, - 1, - 0, - 0, - 0, - 163, - 19, - 1, - 0, - 0, - 0, - 164, - 165, - 7, - 0, - 0, - 0, - 165, - 21, - 1, - 0, - 0, - 0, - 166, - 167, - 5, - 32, - 0, - 0, - 167, - 168, - 5, - 81, - 0, - 0, - 168, - 169, - 3, - 60, - 30, - 0, - 169, - 23, - 1, - 0, - 0, - 0, - 170, - 171, - 5, - 14, - 0, - 0, - 171, - 172, - 5, - 81, - 0, - 0, - 172, - 173, - 5, - 41, - 0, - 0, - 173, - 25, - 1, - 0, - 0, - 0, - 174, - 175, - 5, - 14, - 0, - 0, - 175, - 176, - 5, - 81, - 0, - 0, - 176, - 177, - 5, - 42, - 0, - 0, - 177, - 27, - 1, - 0, - 0, - 0, - 178, - 179, - 5, - 14, - 0, - 0, - 179, - 180, - 5, - 81, - 0, - 0, - 180, - 181, - 5, - 43, - 0, - 0, - 181, - 29, - 1, - 0, - 0, - 0, - 182, - 183, - 5, - 14, - 0, - 0, - 183, - 184, - 5, - 81, - 0, - 0, - 184, - 185, - 5, - 44, - 0, - 0, - 185, - 31, - 1, - 0, - 0, - 0, - 186, - 187, - 3, - 20, - 10, - 0, - 187, - 188, - 5, - 81, - 0, - 0, - 188, - 189, - 5, - 45, - 0, - 0, - 189, - 33, - 1, - 0, - 0, - 0, - 190, - 191, - 3, - 20, - 10, - 0, - 191, - 192, - 5, - 81, - 0, - 0, - 192, - 193, - 5, - 46, - 0, - 0, - 193, - 35, - 1, - 0, - 0, - 0, - 194, - 195, - 3, - 20, - 10, - 0, - 195, - 196, - 5, - 81, - 0, - 0, - 196, - 197, - 3, - 70, - 35, - 0, - 197, - 37, - 1, - 0, - 0, - 0, - 198, - 199, - 5, - 17, - 0, - 0, - 199, - 200, - 5, - 81, - 0, - 0, - 200, - 201, - 5, - 68, - 0, - 0, - 201, - 39, - 1, - 0, - 0, - 0, - 202, - 203, - 5, - 33, - 0, - 0, - 203, - 204, - 5, - 81, - 0, - 0, - 204, - 205, - 5, - 69, - 0, - 0, - 205, - 41, - 1, - 0, - 0, - 0, - 206, - 207, - 5, - 21, - 0, - 0, - 207, - 208, - 5, - 81, - 0, - 0, - 208, - 209, - 5, - 51, - 0, - 0, - 209, - 43, - 1, - 0, - 0, - 0, - 210, - 211, - 5, - 20, - 0, - 0, - 211, - 212, - 5, - 81, - 0, - 0, - 212, - 213, - 5, - 52, - 0, - 0, - 213, - 45, - 1, - 0, - 0, - 0, - 214, - 215, - 5, - 19, - 0, - 0, - 215, - 216, - 5, - 81, - 0, - 0, - 216, - 217, - 5, - 71, - 0, - 0, - 217, - 47, - 1, - 0, - 0, - 0, - 218, - 219, - 5, - 18, - 0, - 0, - 219, - 220, - 5, - 81, - 0, - 0, - 220, - 221, - 5, - 72, - 0, - 0, - 221, - 49, - 1, - 0, - 0, - 0, - 222, - 223, - 5, - 30, - 0, - 0, - 223, - 224, - 5, - 81, - 0, - 0, - 224, - 225, - 5, - 73, - 0, - 0, - 225, - 51, - 1, - 0, - 0, - 0, - 226, - 227, - 5, - 31, - 0, - 0, - 227, - 228, - 5, - 81, - 0, - 0, - 228, - 229, - 5, - 74, - 0, - 0, - 229, - 53, - 1, - 0, - 0, - 0, - 230, - 231, - 5, - 22, - 0, - 0, - 231, - 232, - 5, - 14, - 0, - 0, - 232, - 233, - 5, - 24, - 0, - 0, - 233, - 236, - 1, - 0, - 0, - 0, - 234, - 235, - 5, - 14, - 0, - 0, - 235, - 237, - 5, - 25, - 0, - 0, - 236, - 234, - 1, - 0, - 0, - 0, - 236, - 237, - 1, - 0, - 0, - 0, - 237, - 242, - 1, - 0, - 0, - 0, - 238, - 239, - 5, - 22, - 0, - 0, - 239, - 240, - 5, - 14, - 0, - 0, - 240, - 242, - 5, - 25, - 0, - 0, - 241, - 230, - 1, - 0, - 0, - 0, - 241, - 238, - 1, - 0, - 0, - 0, - 242, - 55, - 1, - 0, - 0, - 0, - 243, - 244, - 5, - 22, - 0, - 0, - 244, - 245, - 5, - 14, - 0, - 0, - 245, - 246, - 5, - 26, - 0, - 0, - 246, - 249, - 1, - 0, - 0, - 0, - 247, - 248, - 5, - 23, - 0, - 0, - 248, - 250, - 3, - 58, - 29, - 0, - 249, - 247, - 1, - 0, - 0, - 0, - 249, - 250, - 1, - 0, - 0, - 0, - 250, - 255, - 1, - 0, - 0, - 0, - 251, - 252, - 5, - 22, - 0, - 0, - 252, - 253, - 5, - 23, - 0, - 0, - 253, - 255, - 3, - 58, - 29, - 0, - 254, - 243, - 1, - 0, - 0, - 0, - 254, - 251, - 1, - 0, - 0, - 0, - 255, - 57, - 1, - 0, - 0, - 0, - 256, - 257, - 5, - 14, - 0, - 0, - 257, - 260, - 5, - 27, - 0, - 0, - 258, - 259, - 5, - 14, - 0, - 0, - 259, - 261, - 5, - 25, - 0, - 0, - 260, - 258, - 1, - 0, - 0, - 0, - 260, - 261, - 1, - 0, - 0, - 0, - 261, - 264, - 1, - 0, - 0, - 0, - 262, - 263, - 5, - 14, - 0, - 0, - 263, - 265, - 5, - 28, - 0, - 0, - 264, - 262, - 1, - 0, - 0, - 0, - 264, - 265, - 1, - 0, - 0, - 0, - 265, - 268, - 1, - 0, - 0, - 0, - 266, - 267, - 5, - 14, - 0, - 0, - 267, - 269, - 5, - 29, - 0, - 0, - 268, - 266, - 1, - 0, - 0, - 0, - 268, - 269, - 1, - 0, - 0, - 0, - 269, - 289, - 1, - 0, - 0, - 0, - 270, - 271, - 5, - 14, - 0, - 0, - 271, - 274, - 5, - 25, - 0, - 0, - 272, - 273, - 5, - 14, - 0, - 0, - 273, - 275, - 5, - 28, - 0, - 0, - 274, - 272, - 1, - 0, - 0, - 0, - 274, - 275, - 1, - 0, - 0, - 0, - 275, - 278, - 1, - 0, - 0, - 0, - 276, - 277, - 5, - 14, - 0, - 0, - 277, - 279, - 5, - 29, - 0, - 0, - 278, - 276, - 1, - 0, - 0, - 0, - 278, - 279, - 1, - 0, - 0, - 0, - 279, - 289, - 1, - 0, - 0, - 0, - 280, - 281, - 5, - 14, - 0, - 0, - 281, - 284, - 5, - 28, - 0, - 0, - 282, - 283, - 5, - 14, - 0, - 0, - 283, - 285, - 5, - 29, - 0, - 0, - 284, - 282, - 1, - 0, - 0, - 0, - 284, - 285, - 1, - 0, - 0, - 0, - 285, - 289, - 1, - 0, - 0, - 0, - 286, - 287, - 5, - 14, - 0, - 0, - 287, - 289, - 5, - 29, - 0, - 0, - 288, - 256, - 1, - 0, - 0, - 0, - 288, - 270, - 1, - 0, - 0, - 0, - 288, - 280, - 1, - 0, - 0, - 0, - 288, - 286, - 1, - 0, - 0, - 0, - 289, - 59, - 1, - 0, - 0, - 0, - 290, - 293, - 3, - 62, - 31, - 0, - 291, - 293, - 3, - 76, - 38, - 0, - 292, - 290, - 1, - 0, - 0, - 0, - 292, - 291, - 1, - 0, - 0, - 0, - 293, - 61, - 1, - 0, - 0, - 0, - 294, - 313, - 5, - 68, - 0, - 0, - 295, - 313, - 5, - 41, - 0, - 0, - 296, - 313, - 5, - 42, - 0, - 0, - 297, - 313, - 5, - 43, - 0, - 0, - 298, - 313, - 5, - 44, - 0, - 0, - 299, - 313, - 5, - 45, - 0, - 0, - 300, - 313, - 5, - 46, - 0, - 0, - 301, - 313, - 5, - 69, - 0, - 0, - 302, - 313, - 5, - 48, - 0, - 0, - 303, - 313, - 5, - 71, - 0, - 0, - 304, - 313, - 5, - 72, - 0, - 0, - 305, - 313, - 5, - 51, - 0, - 0, - 306, - 313, - 5, - 52, - 0, - 0, - 307, - 313, - 5, - 74, - 0, - 0, - 308, - 313, - 5, - 73, - 0, - 0, - 309, - 313, - 5, - 55, - 0, - 0, - 310, - 311, - 5, - 67, - 0, - 0, - 311, - 313, - 5, - 82, - 0, - 0, - 312, - 294, - 1, - 0, - 0, - 0, - 312, - 295, - 1, - 0, - 0, - 0, - 312, - 296, - 1, - 0, - 0, - 0, - 312, - 297, - 1, - 0, - 0, - 0, - 312, - 298, - 1, - 0, - 0, - 0, - 312, - 299, - 1, - 0, - 0, - 0, - 312, - 300, - 1, - 0, - 0, - 0, - 312, - 301, - 1, - 0, - 0, - 0, - 312, - 302, - 1, - 0, - 0, - 0, - 312, - 303, - 1, - 0, - 0, - 0, - 312, - 304, - 1, - 0, - 0, - 0, - 312, - 305, - 1, - 0, - 0, - 0, - 312, - 306, - 1, - 0, - 0, - 0, - 312, - 307, - 1, - 0, - 0, - 0, - 312, - 308, - 1, - 0, - 0, - 0, - 312, - 309, - 1, - 0, - 0, - 0, - 312, - 310, - 1, - 0, - 0, - 0, - 313, - 63, - 1, - 0, - 0, - 0, - 314, - 316, - 5, - 78, - 0, - 0, - 315, - 317, - 5, - 92, - 0, - 0, - 316, - 315, - 1, - 0, - 0, - 0, - 316, - 317, - 1, - 0, - 0, - 0, - 317, - 318, - 1, - 0, - 0, - 0, - 318, - 319, - 5, - 83, - 0, - 0, - 319, - 320, - 3, - 78, - 39, - 0, - 320, - 321, - 5, - 84, - 0, - 0, - 321, - 65, - 1, - 0, - 0, - 0, - 322, - 324, - 5, - 79, - 0, - 0, - 323, - 325, - 5, - 92, - 0, - 0, - 324, - 323, - 1, - 0, - 0, - 0, - 324, - 325, - 1, - 0, - 0, - 0, - 325, - 326, - 1, - 0, - 0, - 0, - 326, - 327, - 5, - 83, - 0, - 0, - 327, - 328, - 3, - 78, - 39, - 0, - 328, - 329, - 5, - 84, - 0, - 0, - 329, - 67, - 1, - 0, - 0, - 0, - 330, - 332, - 5, - 80, - 0, - 0, - 331, - 333, - 5, - 92, - 0, - 0, - 332, - 331, - 1, - 0, - 0, - 0, - 332, - 333, - 1, - 0, - 0, - 0, - 333, - 334, - 1, - 0, - 0, - 0, - 334, - 335, - 5, - 83, - 0, - 0, - 335, - 336, - 3, - 78, - 39, - 0, - 336, - 337, - 5, - 84, - 0, - 0, - 337, - 69, - 1, - 0, - 0, - 0, - 338, - 340, - 5, - 75, - 0, - 0, - 339, - 341, - 5, - 92, - 0, - 0, - 340, - 339, - 1, - 0, - 0, - 0, - 340, - 341, - 1, - 0, - 0, - 0, - 341, - 348, - 1, - 0, - 0, - 0, - 342, - 343, - 5, - 83, - 0, - 0, - 343, - 344, - 3, - 78, - 39, - 0, - 344, - 345, - 5, - 89, - 0, - 0, - 345, - 346, - 3, - 78, - 39, - 0, - 346, - 347, - 5, - 84, - 0, - 0, - 347, - 349, - 1, - 0, - 0, - 0, - 348, - 342, - 1, - 0, - 0, - 0, - 348, - 349, - 1, - 0, - 0, - 0, - 349, - 71, - 1, - 0, - 0, - 0, - 350, - 352, - 5, - 76, - 0, - 0, - 351, - 353, - 5, - 92, - 0, - 0, - 352, - 351, - 1, - 0, - 0, - 0, - 352, - 353, - 1, - 0, - 0, - 0, - 353, - 354, - 1, - 0, - 0, - 0, - 354, - 355, - 5, - 83, - 0, - 0, - 355, - 356, - 3, - 78, - 39, - 0, - 356, - 357, - 5, - 84, - 0, - 0, - 357, - 73, - 1, - 0, - 0, - 0, - 358, - 360, - 5, - 77, - 0, - 0, - 359, - 361, - 5, - 92, - 0, - 0, - 360, - 359, - 1, - 0, - 0, - 0, - 360, - 361, - 1, - 0, - 0, - 0, - 361, - 362, - 1, - 0, - 0, - 0, - 362, - 363, - 5, - 83, - 0, - 0, - 363, - 364, - 3, - 78, - 39, - 0, - 364, - 365, - 5, - 84, - 0, - 0, - 365, - 75, - 1, - 0, - 0, - 0, - 366, - 373, - 3, - 64, - 32, - 0, - 367, - 373, - 3, - 66, - 33, - 0, - 368, - 373, - 3, - 68, - 34, - 0, - 369, - 373, - 3, - 70, - 35, - 0, - 370, - 373, - 3, - 72, - 36, - 0, - 371, - 373, - 3, - 74, - 37, - 0, - 372, - 366, - 1, - 0, - 0, - 0, - 372, - 367, - 1, - 0, - 0, - 0, - 372, - 368, - 1, - 0, - 0, - 0, - 372, - 369, - 1, - 0, - 0, - 0, - 372, - 370, - 1, - 0, - 0, - 0, - 372, - 371, - 1, - 0, - 0, - 0, - 373, - 77, - 1, - 0, - 0, - 0, - 374, - 375, - 5, - 14, - 0, - 0, - 375, - 79, - 1, - 0, - 0, - 0, - 376, - 377, - 7, - 1, - 0, - 0, - 377, - 81, - 1, - 0, - 0, - 0, - 378, - 379, - 3, - 84, - 42, - 0, - 379, - 380, - 5, - 91, - 0, - 0, - 380, - 381, - 3, - 86, - 43, - 0, - 381, - 83, - 1, - 0, - 0, - 0, - 382, - 383, - 7, - 2, - 0, - 0, - 383, - 85, - 1, - 0, - 0, - 0, - 384, - 385, - 7, - 3, - 0, - 0, - 385, - 87, - 1, - 0, - 0, - 0, - 386, - 391, - 3, - 82, - 41, - 0, - 387, - 388, - 5, - 89, - 0, - 0, - 388, - 390, - 3, - 82, - 41, - 0, - 389, - 387, - 1, - 0, - 0, - 0, - 390, - 393, - 1, - 0, - 0, - 0, - 391, - 389, - 1, - 0, - 0, - 0, - 391, - 392, - 1, - 0, - 0, - 0, - 392, - 89, - 1, - 0, - 0, - 0, - 393, - 391, - 1, - 0, - 0, - 0, - 29, - 94, - 110, - 123, - 132, - 139, - 144, - 162, - 236, - 241, - 249, - 254, - 260, - 264, - 268, - 274, - 278, - 284, - 288, - 292, - 312, - 316, - 324, - 332, - 340, - 348, - 352, - 360, - 372, - 391, - ] - - -class TestFileParser(Parser): - - grammarFileName = "TestFileParser.g4" - - atn = ATNDeserializer().deserialize(serializedATN()) - - decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] - - sharedContextCache = PredictionContextCache() - - literalNames = [ - "", - "'### SUBSTRAIT_SCALAR_TEST:'", - "", - "'### SUBSTRAIT_INCLUDE:'", - "", - "''", - "''", - "'overlfow'", - "'rounding'", - "'ERROR'", - "'SATURATE'", - "'SILENT'", - "'TIE_TO_EVEN'", - "'NAN'", - "", - "", - "", - "", - "", - "", - "", - "", - "'P'", - "'T'", - "'Y'", - "'M'", - "'D'", - "'H'", - "'S'", - "'F'", - "", - "", - "'null'", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "'::'", - "", - "'<'", - "'>'", - "'('", - "')'", - "'['", - "']'", - "','", - "'='", - "':'", - "'?'", - "'#'", - "'.'", - ] - - symbolicNames = [ - "", - "SUBSTRAIT_SCALAR_TEST", - "FORMAT_VERSION", - "SUBSTRAIT_INCLUDE", - "DESCRIPTION_LINE", - "ERROR_RESULT", - "UNDEFINED_RESULT", - "OVERFLOW", - "ROUNDING", - "ERROR", - "SATURATE", - "SILENT", - "TIE_TO_EVEN", - "NAN", - "INTEGER_LITERAL", - "DECIMAL_LITERAL", - "FLOAT_LITERAL", - "BOOLEAN_LITERAL", - "TIMESTAMP_TZ_LITERAL", - "TIMESTAMP_LITERAL", - "TIME_LITERAL", - "DATE_LITERAL", - "PERIOD_PREFIX", - "TIME_PREFIX", - "YEAR_SUFFIX", - "M_SUFFIX", - "DAY_SUFFIX", - "HOUR_SUFFIX", - "SECOND_SUFFIX", - "FRACTIONAL_SECOND_SUFFIX", - "INTERVAL_YEAR_LITERAL", - "INTERVAL_DAY_LITERAL", - "NULL_LITERAL", - "STRING_LITERAL", - "LineComment", - "BlockComment", - "Whitespace", - "If", - "Then", - "Else", - "Boolean", - "I8", - "I16", - "I32", - "I64", - "FP32", - "FP64", - "String", - "Binary", - "Timestamp", - "TimestampTZ", - "Date", - "Time", - "IntervalYear", - "IntervalDay", - "UUID", - "Decimal", - "PrecisionTimestamp", - "PrecisionTimestampTZ", - "FixedChar", - "VarChar", - "FixedBinary", - "Struct", - "NStruct", - "List", - "Map", - "ANY", - "UserDefined", - "Bool", - "Str", - "VBin", - "Ts", - "TsTZ", - "IYear", - "IDay", - "Dec", - "PTs", - "PTsTZ", - "FChar", - "VChar", - "FBin", - "DOUBLE_COLON", - "IDENTIFIER", - "O_ANGLE_BRACKET", - "C_ANGLE_BRACKET", - "OPAREN", - "CPAREN", - "OBRACKET", - "CBRACKET", - "COMMA", - "EQ", - "COLON", - "QMARK", - "HASH", - "DOT", - ] - - RULE_doc = 0 - RULE_header = 1 - RULE_version = 2 - RULE_include = 3 - RULE_testGroupDescription = 4 - RULE_testCase = 5 - RULE_testGroup = 6 - RULE_arguments = 7 - RULE_result = 8 - RULE_argument = 9 - RULE_numericLiteral = 10 - RULE_nullArg = 11 - RULE_i8Arg = 12 - RULE_i16Arg = 13 - RULE_i32Arg = 14 - RULE_i64Arg = 15 - RULE_fp32Arg = 16 - RULE_fp64Arg = 17 - RULE_decimalArg = 18 - RULE_booleanArg = 19 - RULE_stringArg = 20 - RULE_dateArg = 21 - RULE_timeArg = 22 - RULE_timestampArg = 23 - RULE_timestampTzArg = 24 - RULE_intervalYearArg = 25 - RULE_intervalDayArg = 26 - RULE_intervalYearLiteral = 27 - RULE_intervalDayLiteral = 28 - RULE_timeInterval = 29 - RULE_datatype = 30 - RULE_scalarType = 31 - RULE_fixedCharType = 32 - RULE_varCharType = 33 - RULE_fixedBinaryType = 34 - RULE_decimalType = 35 - RULE_precisionTimestampType = 36 - RULE_precisionTimestampTZType = 37 - RULE_parameterizedType = 38 - RULE_numericParameter = 39 - RULE_substraitError = 40 - RULE_func_option = 41 - RULE_option_name = 42 - RULE_option_value = 43 - RULE_func_options = 44 - - ruleNames = [ - "doc", - "header", - "version", - "include", - "testGroupDescription", - "testCase", - "testGroup", - "arguments", - "result", - "argument", - "numericLiteral", - "nullArg", - "i8Arg", - "i16Arg", - "i32Arg", - "i64Arg", - "fp32Arg", - "fp64Arg", - "decimalArg", - "booleanArg", - "stringArg", - "dateArg", - "timeArg", - "timestampArg", - "timestampTzArg", - "intervalYearArg", - "intervalDayArg", - "intervalYearLiteral", - "intervalDayLiteral", - "timeInterval", - "datatype", - "scalarType", - "fixedCharType", - "varCharType", - "fixedBinaryType", - "decimalType", - "precisionTimestampType", - "precisionTimestampTZType", - "parameterizedType", - "numericParameter", - "substraitError", - "func_option", - "option_name", - "option_value", - "func_options", - ] - - EOF = Token.EOF - SUBSTRAIT_SCALAR_TEST = 1 - FORMAT_VERSION = 2 - SUBSTRAIT_INCLUDE = 3 - DESCRIPTION_LINE = 4 - ERROR_RESULT = 5 - UNDEFINED_RESULT = 6 - OVERFLOW = 7 - ROUNDING = 8 - ERROR = 9 - SATURATE = 10 - SILENT = 11 - TIE_TO_EVEN = 12 - NAN = 13 - INTEGER_LITERAL = 14 - DECIMAL_LITERAL = 15 - FLOAT_LITERAL = 16 - BOOLEAN_LITERAL = 17 - TIMESTAMP_TZ_LITERAL = 18 - TIMESTAMP_LITERAL = 19 - TIME_LITERAL = 20 - DATE_LITERAL = 21 - PERIOD_PREFIX = 22 - TIME_PREFIX = 23 - YEAR_SUFFIX = 24 - M_SUFFIX = 25 - DAY_SUFFIX = 26 - HOUR_SUFFIX = 27 - SECOND_SUFFIX = 28 - FRACTIONAL_SECOND_SUFFIX = 29 - INTERVAL_YEAR_LITERAL = 30 - INTERVAL_DAY_LITERAL = 31 - NULL_LITERAL = 32 - STRING_LITERAL = 33 - LineComment = 34 - BlockComment = 35 - Whitespace = 36 - If = 37 - Then = 38 - Else = 39 - Boolean = 40 - I8 = 41 - I16 = 42 - I32 = 43 - I64 = 44 - FP32 = 45 - FP64 = 46 - String = 47 - Binary = 48 - Timestamp = 49 - TimestampTZ = 50 - Date = 51 - Time = 52 - IntervalYear = 53 - IntervalDay = 54 - UUID = 55 - Decimal = 56 - PrecisionTimestamp = 57 - PrecisionTimestampTZ = 58 - FixedChar = 59 - VarChar = 60 - FixedBinary = 61 - Struct = 62 - NStruct = 63 - List = 64 - Map = 65 - ANY = 66 - UserDefined = 67 - Bool = 68 - Str = 69 - VBin = 70 - Ts = 71 - TsTZ = 72 - IYear = 73 - IDay = 74 - Dec = 75 - PTs = 76 - PTsTZ = 77 - FChar = 78 - VChar = 79 - FBin = 80 - DOUBLE_COLON = 81 - IDENTIFIER = 82 - O_ANGLE_BRACKET = 83 - C_ANGLE_BRACKET = 84 - OPAREN = 85 - CPAREN = 86 - OBRACKET = 87 - CBRACKET = 88 - COMMA = 89 - EQ = 90 - COLON = 91 - QMARK = 92 - HASH = 93 - DOT = 94 - - def __init__(self, input: TokenStream, output: TextIO = sys.stdout): - super().__init__(input, output) - self.checkVersion("4.13.2") - self._interp = ParserATNSimulator( - self, self.atn, self.decisionsToDFA, self.sharedContextCache - ) - self._predicates = None - - class DocContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def header(self): - return self.getTypedRuleContext(TestFileParser.HeaderContext, 0) - - def EOF(self): - return self.getToken(TestFileParser.EOF, 0) - - def testGroup(self, i: int = None): - if i is None: - return self.getTypedRuleContexts(TestFileParser.TestGroupContext) - else: - return self.getTypedRuleContext(TestFileParser.TestGroupContext, i) - - def getRuleIndex(self): - return TestFileParser.RULE_doc - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDoc"): - listener.enterDoc(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDoc"): - listener.exitDoc(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDoc"): - return visitor.visitDoc(self) - else: - return visitor.visitChildren(self) - - def doc(self): - - localctx = TestFileParser.DocContext(self, self._ctx, self.state) - self.enterRule(localctx, 0, self.RULE_doc) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 90 - self.header() - self.state = 92 - self._errHandler.sync(self) - _la = self._input.LA(1) - while True: - self.state = 91 - self.testGroup() - self.state = 94 - self._errHandler.sync(self) - _la = self._input.LA(1) - if not (_la == 4): - break - - self.state = 96 - self.match(TestFileParser.EOF) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class HeaderContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def version(self): - return self.getTypedRuleContext(TestFileParser.VersionContext, 0) - - def include(self): - return self.getTypedRuleContext(TestFileParser.IncludeContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_header - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterHeader"): - listener.enterHeader(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitHeader"): - listener.exitHeader(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitHeader"): - return visitor.visitHeader(self) - else: - return visitor.visitChildren(self) - - def header(self): - - localctx = TestFileParser.HeaderContext(self, self._ctx, self.state) - self.enterRule(localctx, 2, self.RULE_header) - try: - self.enterOuterAlt(localctx, 1) - self.state = 98 - self.version() - self.state = 99 - self.include() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class VersionContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def SUBSTRAIT_SCALAR_TEST(self): - return self.getToken(TestFileParser.SUBSTRAIT_SCALAR_TEST, 0) - - def FORMAT_VERSION(self): - return self.getToken(TestFileParser.FORMAT_VERSION, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_version - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterVersion"): - listener.enterVersion(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitVersion"): - listener.exitVersion(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitVersion"): - return visitor.visitVersion(self) - else: - return visitor.visitChildren(self) - - def version(self): - - localctx = TestFileParser.VersionContext(self, self._ctx, self.state) - self.enterRule(localctx, 4, self.RULE_version) - try: - self.enterOuterAlt(localctx, 1) - self.state = 101 - self.match(TestFileParser.SUBSTRAIT_SCALAR_TEST) - self.state = 102 - self.match(TestFileParser.FORMAT_VERSION) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class IncludeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def SUBSTRAIT_INCLUDE(self): - return self.getToken(TestFileParser.SUBSTRAIT_INCLUDE, 0) - - def STRING_LITERAL(self, i: int = None): - if i is None: - return self.getTokens(TestFileParser.STRING_LITERAL) - else: - return self.getToken(TestFileParser.STRING_LITERAL, i) - - def COMMA(self, i: int = None): - if i is None: - return self.getTokens(TestFileParser.COMMA) - else: - return self.getToken(TestFileParser.COMMA, i) - - def getRuleIndex(self): - return TestFileParser.RULE_include - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterInclude"): - listener.enterInclude(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitInclude"): - listener.exitInclude(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitInclude"): - return visitor.visitInclude(self) - else: - return visitor.visitChildren(self) - - def include(self): - - localctx = TestFileParser.IncludeContext(self, self._ctx, self.state) - self.enterRule(localctx, 6, self.RULE_include) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 104 - self.match(TestFileParser.SUBSTRAIT_INCLUDE) - self.state = 105 - self.match(TestFileParser.STRING_LITERAL) - self.state = 110 - self._errHandler.sync(self) - _la = self._input.LA(1) - while _la == 89: - self.state = 106 - self.match(TestFileParser.COMMA) - self.state = 107 - self.match(TestFileParser.STRING_LITERAL) - self.state = 112 - self._errHandler.sync(self) - _la = self._input.LA(1) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TestGroupDescriptionContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def DESCRIPTION_LINE(self): - return self.getToken(TestFileParser.DESCRIPTION_LINE, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_testGroupDescription - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTestGroupDescription"): - listener.enterTestGroupDescription(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTestGroupDescription"): - listener.exitTestGroupDescription(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTestGroupDescription"): - return visitor.visitTestGroupDescription(self) - else: - return visitor.visitChildren(self) - - def testGroupDescription(self): - - localctx = TestFileParser.TestGroupDescriptionContext( - self, self._ctx, self.state - ) - self.enterRule(localctx, 8, self.RULE_testGroupDescription) - try: - self.enterOuterAlt(localctx, 1) - self.state = 113 - self.match(TestFileParser.DESCRIPTION_LINE) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TestCaseContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - self.functionName = None # Token - - def OPAREN(self): - return self.getToken(TestFileParser.OPAREN, 0) - - def arguments(self): - return self.getTypedRuleContext(TestFileParser.ArgumentsContext, 0) - - def CPAREN(self): - return self.getToken(TestFileParser.CPAREN, 0) - - def EQ(self): - return self.getToken(TestFileParser.EQ, 0) - - def result(self): - return self.getTypedRuleContext(TestFileParser.ResultContext, 0) - - def IDENTIFIER(self): - return self.getToken(TestFileParser.IDENTIFIER, 0) - - def OBRACKET(self): - return self.getToken(TestFileParser.OBRACKET, 0) - - def func_options(self): - return self.getTypedRuleContext(TestFileParser.Func_optionsContext, 0) - - def CBRACKET(self): - return self.getToken(TestFileParser.CBRACKET, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_testCase - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTestCase"): - listener.enterTestCase(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTestCase"): - listener.exitTestCase(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTestCase"): - return visitor.visitTestCase(self) - else: - return visitor.visitChildren(self) - - def testCase(self): - - localctx = TestFileParser.TestCaseContext(self, self._ctx, self.state) - self.enterRule(localctx, 10, self.RULE_testCase) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 115 - localctx.functionName = self.match(TestFileParser.IDENTIFIER) - self.state = 116 - self.match(TestFileParser.OPAREN) - self.state = 117 - self.arguments() - self.state = 118 - self.match(TestFileParser.CPAREN) - self.state = 123 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 87: - self.state = 119 - self.match(TestFileParser.OBRACKET) - self.state = 120 - self.func_options() - self.state = 121 - self.match(TestFileParser.CBRACKET) - - self.state = 125 - self.match(TestFileParser.EQ) - self.state = 126 - self.result() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TestGroupContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def testGroupDescription(self): - return self.getTypedRuleContext( - TestFileParser.TestGroupDescriptionContext, 0 - ) - - def testCase(self, i: int = None): - if i is None: - return self.getTypedRuleContexts(TestFileParser.TestCaseContext) - else: - return self.getTypedRuleContext(TestFileParser.TestCaseContext, i) - - def getRuleIndex(self): - return TestFileParser.RULE_testGroup - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTestGroup"): - listener.enterTestGroup(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTestGroup"): - listener.exitTestGroup(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTestGroup"): - return visitor.visitTestGroup(self) - else: - return visitor.visitChildren(self) - - def testGroup(self): - - localctx = TestFileParser.TestGroupContext(self, self._ctx, self.state) - self.enterRule(localctx, 12, self.RULE_testGroup) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 128 - self.testGroupDescription() - self.state = 130 - self._errHandler.sync(self) - _la = self._input.LA(1) - while True: - self.state = 129 - self.testCase() - self.state = 132 - self._errHandler.sync(self) - _la = self._input.LA(1) - if not (_la == 82): - break - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class ArgumentsContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def argument(self, i: int = None): - if i is None: - return self.getTypedRuleContexts(TestFileParser.ArgumentContext) - else: - return self.getTypedRuleContext(TestFileParser.ArgumentContext, i) - - def COMMA(self, i: int = None): - if i is None: - return self.getTokens(TestFileParser.COMMA) - else: - return self.getToken(TestFileParser.COMMA, i) - - def getRuleIndex(self): - return TestFileParser.RULE_arguments - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArguments"): - listener.enterArguments(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArguments"): - listener.exitArguments(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitArguments"): - return visitor.visitArguments(self) - else: - return visitor.visitChildren(self) - - def arguments(self): - - localctx = TestFileParser.ArgumentsContext(self, self._ctx, self.state) - self.enterRule(localctx, 14, self.RULE_arguments) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 134 - self.argument() - self.state = 139 - self._errHandler.sync(self) - _la = self._input.LA(1) - while _la == 89: - self.state = 135 - self.match(TestFileParser.COMMA) - self.state = 136 - self.argument() - self.state = 141 - self._errHandler.sync(self) - _la = self._input.LA(1) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class ResultContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def argument(self): - return self.getTypedRuleContext(TestFileParser.ArgumentContext, 0) - - def substraitError(self): - return self.getTypedRuleContext(TestFileParser.SubstraitErrorContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_result - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterResult"): - listener.enterResult(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitResult"): - listener.exitResult(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitResult"): - return visitor.visitResult(self) - else: - return visitor.visitChildren(self) - - def result(self): - - localctx = TestFileParser.ResultContext(self, self._ctx, self.state) - self.enterRule(localctx, 16, self.RULE_result) - try: - self.state = 144 - self._errHandler.sync(self) - token = self._input.LA(1) - if token in [14, 15, 16, 17, 18, 19, 20, 21, 30, 31, 32, 33]: - self.enterOuterAlt(localctx, 1) - self.state = 142 - self.argument() - pass - elif token in [5, 6]: - self.enterOuterAlt(localctx, 2) - self.state = 143 - self.substraitError() - pass - else: - raise NoViableAltException(self) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class ArgumentContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def nullArg(self): - return self.getTypedRuleContext(TestFileParser.NullArgContext, 0) - - def i8Arg(self): - return self.getTypedRuleContext(TestFileParser.I8ArgContext, 0) - - def i16Arg(self): - return self.getTypedRuleContext(TestFileParser.I16ArgContext, 0) - - def i32Arg(self): - return self.getTypedRuleContext(TestFileParser.I32ArgContext, 0) - - def i64Arg(self): - return self.getTypedRuleContext(TestFileParser.I64ArgContext, 0) - - def fp32Arg(self): - return self.getTypedRuleContext(TestFileParser.Fp32ArgContext, 0) - - def fp64Arg(self): - return self.getTypedRuleContext(TestFileParser.Fp64ArgContext, 0) - - def booleanArg(self): - return self.getTypedRuleContext(TestFileParser.BooleanArgContext, 0) - - def stringArg(self): - return self.getTypedRuleContext(TestFileParser.StringArgContext, 0) - - def decimalArg(self): - return self.getTypedRuleContext(TestFileParser.DecimalArgContext, 0) - - def dateArg(self): - return self.getTypedRuleContext(TestFileParser.DateArgContext, 0) - - def timeArg(self): - return self.getTypedRuleContext(TestFileParser.TimeArgContext, 0) - - def timestampArg(self): - return self.getTypedRuleContext(TestFileParser.TimestampArgContext, 0) - - def timestampTzArg(self): - return self.getTypedRuleContext(TestFileParser.TimestampTzArgContext, 0) - - def intervalYearArg(self): - return self.getTypedRuleContext(TestFileParser.IntervalYearArgContext, 0) - - def intervalDayArg(self): - return self.getTypedRuleContext(TestFileParser.IntervalDayArgContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_argument - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterArgument"): - listener.enterArgument(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitArgument"): - listener.exitArgument(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitArgument"): - return visitor.visitArgument(self) - else: - return visitor.visitChildren(self) - - def argument(self): - - localctx = TestFileParser.ArgumentContext(self, self._ctx, self.state) - self.enterRule(localctx, 18, self.RULE_argument) - try: - self.state = 162 - self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 6, self._ctx) - if la_ == 1: - self.enterOuterAlt(localctx, 1) - self.state = 146 - self.nullArg() - pass - - elif la_ == 2: - self.enterOuterAlt(localctx, 2) - self.state = 147 - self.i8Arg() - pass - - elif la_ == 3: - self.enterOuterAlt(localctx, 3) - self.state = 148 - self.i16Arg() - pass - - elif la_ == 4: - self.enterOuterAlt(localctx, 4) - self.state = 149 - self.i32Arg() - pass - - elif la_ == 5: - self.enterOuterAlt(localctx, 5) - self.state = 150 - self.i64Arg() - pass - - elif la_ == 6: - self.enterOuterAlt(localctx, 6) - self.state = 151 - self.fp32Arg() - pass - - elif la_ == 7: - self.enterOuterAlt(localctx, 7) - self.state = 152 - self.fp64Arg() - pass - - elif la_ == 8: - self.enterOuterAlt(localctx, 8) - self.state = 153 - self.booleanArg() - pass - - elif la_ == 9: - self.enterOuterAlt(localctx, 9) - self.state = 154 - self.stringArg() - pass - - elif la_ == 10: - self.enterOuterAlt(localctx, 10) - self.state = 155 - self.decimalArg() - pass - - elif la_ == 11: - self.enterOuterAlt(localctx, 11) - self.state = 156 - self.dateArg() - pass - - elif la_ == 12: - self.enterOuterAlt(localctx, 12) - self.state = 157 - self.timeArg() - pass - - elif la_ == 13: - self.enterOuterAlt(localctx, 13) - self.state = 158 - self.timestampArg() - pass - - elif la_ == 14: - self.enterOuterAlt(localctx, 14) - self.state = 159 - self.timestampTzArg() - pass - - elif la_ == 15: - self.enterOuterAlt(localctx, 15) - self.state = 160 - self.intervalYearArg() - pass - - elif la_ == 16: - self.enterOuterAlt(localctx, 16) - self.state = 161 - self.intervalDayArg() - pass - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class NumericLiteralContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def DECIMAL_LITERAL(self): - return self.getToken(TestFileParser.DECIMAL_LITERAL, 0) - - def INTEGER_LITERAL(self): - return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - - def FLOAT_LITERAL(self): - return self.getToken(TestFileParser.FLOAT_LITERAL, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_numericLiteral - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterNumericLiteral"): - listener.enterNumericLiteral(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitNumericLiteral"): - listener.exitNumericLiteral(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitNumericLiteral"): - return visitor.visitNumericLiteral(self) - else: - return visitor.visitChildren(self) - - def numericLiteral(self): - - localctx = TestFileParser.NumericLiteralContext(self, self._ctx, self.state) - self.enterRule(localctx, 20, self.RULE_numericLiteral) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 164 - _la = self._input.LA(1) - if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 114688) != 0)): - self._errHandler.recoverInline(self) - else: - self._errHandler.reportMatch(self) - self.consume() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class NullArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def NULL_LITERAL(self): - return self.getToken(TestFileParser.NULL_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def datatype(self): - return self.getTypedRuleContext(TestFileParser.DatatypeContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_nullArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterNullArg"): - listener.enterNullArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitNullArg"): - listener.exitNullArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitNullArg"): - return visitor.visitNullArg(self) - else: - return visitor.visitChildren(self) - - def nullArg(self): - - localctx = TestFileParser.NullArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 22, self.RULE_nullArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 166 - self.match(TestFileParser.NULL_LITERAL) - self.state = 167 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 168 - self.datatype() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class I8ArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def INTEGER_LITERAL(self): - return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def I8(self): - return self.getToken(TestFileParser.I8, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_i8Arg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI8Arg"): - listener.enterI8Arg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI8Arg"): - listener.exitI8Arg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI8Arg"): - return visitor.visitI8Arg(self) - else: - return visitor.visitChildren(self) - - def i8Arg(self): - - localctx = TestFileParser.I8ArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 24, self.RULE_i8Arg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 170 - self.match(TestFileParser.INTEGER_LITERAL) - self.state = 171 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 172 - self.match(TestFileParser.I8) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class I16ArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def INTEGER_LITERAL(self): - return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def I16(self): - return self.getToken(TestFileParser.I16, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_i16Arg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI16Arg"): - listener.enterI16Arg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI16Arg"): - listener.exitI16Arg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI16Arg"): - return visitor.visitI16Arg(self) - else: - return visitor.visitChildren(self) - - def i16Arg(self): - - localctx = TestFileParser.I16ArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 26, self.RULE_i16Arg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 174 - self.match(TestFileParser.INTEGER_LITERAL) - self.state = 175 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 176 - self.match(TestFileParser.I16) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class I32ArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def INTEGER_LITERAL(self): - return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def I32(self): - return self.getToken(TestFileParser.I32, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_i32Arg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI32Arg"): - listener.enterI32Arg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI32Arg"): - listener.exitI32Arg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI32Arg"): - return visitor.visitI32Arg(self) - else: - return visitor.visitChildren(self) - - def i32Arg(self): - - localctx = TestFileParser.I32ArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 28, self.RULE_i32Arg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 178 - self.match(TestFileParser.INTEGER_LITERAL) - self.state = 179 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 180 - self.match(TestFileParser.I32) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class I64ArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def INTEGER_LITERAL(self): - return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def I64(self): - return self.getToken(TestFileParser.I64, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_i64Arg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI64Arg"): - listener.enterI64Arg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI64Arg"): - listener.exitI64Arg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI64Arg"): - return visitor.visitI64Arg(self) - else: - return visitor.visitChildren(self) - - def i64Arg(self): - - localctx = TestFileParser.I64ArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 30, self.RULE_i64Arg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 182 - self.match(TestFileParser.INTEGER_LITERAL) - self.state = 183 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 184 - self.match(TestFileParser.I64) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class Fp32ArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def numericLiteral(self): - return self.getTypedRuleContext(TestFileParser.NumericLiteralContext, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def FP32(self): - return self.getToken(TestFileParser.FP32, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_fp32Arg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFp32Arg"): - listener.enterFp32Arg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFp32Arg"): - listener.exitFp32Arg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFp32Arg"): - return visitor.visitFp32Arg(self) - else: - return visitor.visitChildren(self) - - def fp32Arg(self): - - localctx = TestFileParser.Fp32ArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 32, self.RULE_fp32Arg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 186 - self.numericLiteral() - self.state = 187 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 188 - self.match(TestFileParser.FP32) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class Fp64ArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def numericLiteral(self): - return self.getTypedRuleContext(TestFileParser.NumericLiteralContext, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def FP64(self): - return self.getToken(TestFileParser.FP64, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_fp64Arg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFp64Arg"): - listener.enterFp64Arg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFp64Arg"): - listener.exitFp64Arg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFp64Arg"): - return visitor.visitFp64Arg(self) - else: - return visitor.visitChildren(self) - - def fp64Arg(self): - - localctx = TestFileParser.Fp64ArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 34, self.RULE_fp64Arg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 190 - self.numericLiteral() - self.state = 191 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 192 - self.match(TestFileParser.FP64) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class DecimalArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def numericLiteral(self): - return self.getTypedRuleContext(TestFileParser.NumericLiteralContext, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def decimalType(self): - return self.getTypedRuleContext(TestFileParser.DecimalTypeContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_decimalArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDecimalArg"): - listener.enterDecimalArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDecimalArg"): - listener.exitDecimalArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDecimalArg"): - return visitor.visitDecimalArg(self) - else: - return visitor.visitChildren(self) - - def decimalArg(self): - - localctx = TestFileParser.DecimalArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 36, self.RULE_decimalArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 194 - self.numericLiteral() - self.state = 195 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 196 - self.decimalType() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class BooleanArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def BOOLEAN_LITERAL(self): - return self.getToken(TestFileParser.BOOLEAN_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def Bool(self): - return self.getToken(TestFileParser.Bool, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_booleanArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBooleanArg"): - listener.enterBooleanArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBooleanArg"): - listener.exitBooleanArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitBooleanArg"): - return visitor.visitBooleanArg(self) - else: - return visitor.visitChildren(self) - - def booleanArg(self): - - localctx = TestFileParser.BooleanArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 38, self.RULE_booleanArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 198 - self.match(TestFileParser.BOOLEAN_LITERAL) - self.state = 199 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 200 - self.match(TestFileParser.Bool) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class StringArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def STRING_LITERAL(self): - return self.getToken(TestFileParser.STRING_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def Str(self): - return self.getToken(TestFileParser.Str, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_stringArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterStringArg"): - listener.enterStringArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitStringArg"): - listener.exitStringArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitStringArg"): - return visitor.visitStringArg(self) - else: - return visitor.visitChildren(self) - - def stringArg(self): - - localctx = TestFileParser.StringArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 40, self.RULE_stringArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 202 - self.match(TestFileParser.STRING_LITERAL) - self.state = 203 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 204 - self.match(TestFileParser.Str) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class DateArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def DATE_LITERAL(self): - return self.getToken(TestFileParser.DATE_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def Date(self): - return self.getToken(TestFileParser.Date, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_dateArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDateArg"): - listener.enterDateArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDateArg"): - listener.exitDateArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDateArg"): - return visitor.visitDateArg(self) - else: - return visitor.visitChildren(self) - - def dateArg(self): - - localctx = TestFileParser.DateArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 42, self.RULE_dateArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 206 - self.match(TestFileParser.DATE_LITERAL) - self.state = 207 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 208 - self.match(TestFileParser.Date) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TimeArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def TIME_LITERAL(self): - return self.getToken(TestFileParser.TIME_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def Time(self): - return self.getToken(TestFileParser.Time, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_timeArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeArg"): - listener.enterTimeArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeArg"): - listener.exitTimeArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTimeArg"): - return visitor.visitTimeArg(self) - else: - return visitor.visitChildren(self) - - def timeArg(self): - - localctx = TestFileParser.TimeArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 44, self.RULE_timeArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 210 - self.match(TestFileParser.TIME_LITERAL) - self.state = 211 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 212 - self.match(TestFileParser.Time) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TimestampArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def TIMESTAMP_LITERAL(self): - return self.getToken(TestFileParser.TIMESTAMP_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def Ts(self): - return self.getToken(TestFileParser.Ts, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_timestampArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimestampArg"): - listener.enterTimestampArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimestampArg"): - listener.exitTimestampArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTimestampArg"): - return visitor.visitTimestampArg(self) - else: - return visitor.visitChildren(self) - - def timestampArg(self): - - localctx = TestFileParser.TimestampArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 46, self.RULE_timestampArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 214 - self.match(TestFileParser.TIMESTAMP_LITERAL) - self.state = 215 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 216 - self.match(TestFileParser.Ts) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TimestampTzArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def TIMESTAMP_TZ_LITERAL(self): - return self.getToken(TestFileParser.TIMESTAMP_TZ_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def TsTZ(self): - return self.getToken(TestFileParser.TsTZ, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_timestampTzArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimestampTzArg"): - listener.enterTimestampTzArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimestampTzArg"): - listener.exitTimestampTzArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTimestampTzArg"): - return visitor.visitTimestampTzArg(self) - else: - return visitor.visitChildren(self) - - def timestampTzArg(self): - - localctx = TestFileParser.TimestampTzArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 48, self.RULE_timestampTzArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 218 - self.match(TestFileParser.TIMESTAMP_TZ_LITERAL) - self.state = 219 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 220 - self.match(TestFileParser.TsTZ) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class IntervalYearArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def INTERVAL_YEAR_LITERAL(self): - return self.getToken(TestFileParser.INTERVAL_YEAR_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def IYear(self): - return self.getToken(TestFileParser.IYear, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_intervalYearArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntervalYearArg"): - listener.enterIntervalYearArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntervalYearArg"): - listener.exitIntervalYearArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitIntervalYearArg"): - return visitor.visitIntervalYearArg(self) - else: - return visitor.visitChildren(self) - - def intervalYearArg(self): - - localctx = TestFileParser.IntervalYearArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 50, self.RULE_intervalYearArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 222 - self.match(TestFileParser.INTERVAL_YEAR_LITERAL) - self.state = 223 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 224 - self.match(TestFileParser.IYear) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class IntervalDayArgContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def INTERVAL_DAY_LITERAL(self): - return self.getToken(TestFileParser.INTERVAL_DAY_LITERAL, 0) - - def DOUBLE_COLON(self): - return self.getToken(TestFileParser.DOUBLE_COLON, 0) - - def IDay(self): - return self.getToken(TestFileParser.IDay, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_intervalDayArg - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntervalDayArg"): - listener.enterIntervalDayArg(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntervalDayArg"): - listener.exitIntervalDayArg(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitIntervalDayArg"): - return visitor.visitIntervalDayArg(self) - else: - return visitor.visitChildren(self) - - def intervalDayArg(self): - - localctx = TestFileParser.IntervalDayArgContext(self, self._ctx, self.state) - self.enterRule(localctx, 52, self.RULE_intervalDayArg) - try: - self.enterOuterAlt(localctx, 1) - self.state = 226 - self.match(TestFileParser.INTERVAL_DAY_LITERAL) - self.state = 227 - self.match(TestFileParser.DOUBLE_COLON) - self.state = 228 - self.match(TestFileParser.IDay) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class IntervalYearLiteralContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - self.years = None # Token - self.months = None # Token - - def PERIOD_PREFIX(self): - return self.getToken(TestFileParser.PERIOD_PREFIX, 0) - - def YEAR_SUFFIX(self): - return self.getToken(TestFileParser.YEAR_SUFFIX, 0) - - def INTEGER_LITERAL(self, i: int = None): - if i is None: - return self.getTokens(TestFileParser.INTEGER_LITERAL) - else: - return self.getToken(TestFileParser.INTEGER_LITERAL, i) - - def M_SUFFIX(self): - return self.getToken(TestFileParser.M_SUFFIX, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_intervalYearLiteral - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntervalYearLiteral"): - listener.enterIntervalYearLiteral(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntervalYearLiteral"): - listener.exitIntervalYearLiteral(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitIntervalYearLiteral"): - return visitor.visitIntervalYearLiteral(self) - else: - return visitor.visitChildren(self) - - def intervalYearLiteral(self): - - localctx = TestFileParser.IntervalYearLiteralContext( - self, self._ctx, self.state - ) - self.enterRule(localctx, 54, self.RULE_intervalYearLiteral) - self._la = 0 # Token type - try: - self.state = 241 - self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) - if la_ == 1: - self.enterOuterAlt(localctx, 1) - self.state = 230 - self.match(TestFileParser.PERIOD_PREFIX) - - self.state = 231 - localctx.years = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 232 - self.match(TestFileParser.YEAR_SUFFIX) - self.state = 236 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 14: - self.state = 234 - localctx.months = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 235 - self.match(TestFileParser.M_SUFFIX) - - pass - - elif la_ == 2: - self.enterOuterAlt(localctx, 2) - self.state = 238 - self.match(TestFileParser.PERIOD_PREFIX) - - self.state = 239 - localctx.months = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 240 - self.match(TestFileParser.M_SUFFIX) - pass - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class IntervalDayLiteralContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - self.days = None # Token - - def PERIOD_PREFIX(self): - return self.getToken(TestFileParser.PERIOD_PREFIX, 0) - - def DAY_SUFFIX(self): - return self.getToken(TestFileParser.DAY_SUFFIX, 0) - - def INTEGER_LITERAL(self): - return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - - def TIME_PREFIX(self): - return self.getToken(TestFileParser.TIME_PREFIX, 0) - - def timeInterval(self): - return self.getTypedRuleContext(TestFileParser.TimeIntervalContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_intervalDayLiteral - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntervalDayLiteral"): - listener.enterIntervalDayLiteral(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntervalDayLiteral"): - listener.exitIntervalDayLiteral(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitIntervalDayLiteral"): - return visitor.visitIntervalDayLiteral(self) - else: - return visitor.visitChildren(self) - - def intervalDayLiteral(self): - - localctx = TestFileParser.IntervalDayLiteralContext(self, self._ctx, self.state) - self.enterRule(localctx, 56, self.RULE_intervalDayLiteral) - self._la = 0 # Token type - try: - self.state = 254 - self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 10, self._ctx) - if la_ == 1: - self.enterOuterAlt(localctx, 1) - self.state = 243 - self.match(TestFileParser.PERIOD_PREFIX) - - self.state = 244 - localctx.days = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 245 - self.match(TestFileParser.DAY_SUFFIX) - self.state = 249 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 23: - self.state = 247 - self.match(TestFileParser.TIME_PREFIX) - self.state = 248 - self.timeInterval() - - pass - - elif la_ == 2: - self.enterOuterAlt(localctx, 2) - self.state = 251 - self.match(TestFileParser.PERIOD_PREFIX) - self.state = 252 - self.match(TestFileParser.TIME_PREFIX) - self.state = 253 - self.timeInterval() - pass - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class TimeIntervalContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - self.hours = None # Token - self.minutes = None # Token - self.seconds = None # Token - self.fractionalSeconds = None # Token - - def HOUR_SUFFIX(self): - return self.getToken(TestFileParser.HOUR_SUFFIX, 0) - - def INTEGER_LITERAL(self, i: int = None): - if i is None: - return self.getTokens(TestFileParser.INTEGER_LITERAL) - else: - return self.getToken(TestFileParser.INTEGER_LITERAL, i) - - def M_SUFFIX(self): - return self.getToken(TestFileParser.M_SUFFIX, 0) - - def SECOND_SUFFIX(self): - return self.getToken(TestFileParser.SECOND_SUFFIX, 0) - - def FRACTIONAL_SECOND_SUFFIX(self): - return self.getToken(TestFileParser.FRACTIONAL_SECOND_SUFFIX, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_timeInterval - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimeInterval"): - listener.enterTimeInterval(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimeInterval"): - listener.exitTimeInterval(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTimeInterval"): - return visitor.visitTimeInterval(self) - else: - return visitor.visitChildren(self) - - def timeInterval(self): - - localctx = TestFileParser.TimeIntervalContext(self, self._ctx, self.state) - self.enterRule(localctx, 58, self.RULE_timeInterval) - self._la = 0 # Token type - try: - self.state = 288 - self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 17, self._ctx) - if la_ == 1: - self.enterOuterAlt(localctx, 1) - self.state = 256 - localctx.hours = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 257 - self.match(TestFileParser.HOUR_SUFFIX) - self.state = 260 - self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 11, self._ctx) - if la_ == 1: - self.state = 258 - localctx.minutes = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 259 - self.match(TestFileParser.M_SUFFIX) - - self.state = 264 - self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) - if la_ == 1: - self.state = 262 - localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 263 - self.match(TestFileParser.SECOND_SUFFIX) - - self.state = 268 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 14: - self.state = 266 - localctx.fractionalSeconds = self.match( - TestFileParser.INTEGER_LITERAL - ) - self.state = 267 - self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) - - pass - - elif la_ == 2: - self.enterOuterAlt(localctx, 2) - self.state = 270 - localctx.minutes = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 271 - self.match(TestFileParser.M_SUFFIX) - self.state = 274 - self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input, 14, self._ctx) - if la_ == 1: - self.state = 272 - localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 273 - self.match(TestFileParser.SECOND_SUFFIX) - - self.state = 278 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 14: - self.state = 276 - localctx.fractionalSeconds = self.match( - TestFileParser.INTEGER_LITERAL - ) - self.state = 277 - self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) - - pass - - elif la_ == 3: - self.enterOuterAlt(localctx, 3) - self.state = 280 - localctx.seconds = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 281 - self.match(TestFileParser.SECOND_SUFFIX) - self.state = 284 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 14: - self.state = 282 - localctx.fractionalSeconds = self.match( - TestFileParser.INTEGER_LITERAL - ) - self.state = 283 - self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) - - pass - - elif la_ == 4: - self.enterOuterAlt(localctx, 4) - self.state = 286 - localctx.fractionalSeconds = self.match(TestFileParser.INTEGER_LITERAL) - self.state = 287 - self.match(TestFileParser.FRACTIONAL_SECOND_SUFFIX) - pass - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class DatatypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def scalarType(self): - return self.getTypedRuleContext(TestFileParser.ScalarTypeContext, 0) - - def parameterizedType(self): - return self.getTypedRuleContext(TestFileParser.ParameterizedTypeContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_datatype - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDatatype"): - listener.enterDatatype(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDatatype"): - listener.exitDatatype(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDatatype"): - return visitor.visitDatatype(self) - else: - return visitor.visitChildren(self) - - def datatype(self): - - localctx = TestFileParser.DatatypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 60, self.RULE_datatype) - try: - self.state = 292 - self._errHandler.sync(self) - token = self._input.LA(1) - if token in [ - 41, - 42, - 43, - 44, - 45, - 46, - 48, - 51, - 52, - 55, - 67, - 68, - 69, - 71, - 72, - 73, - 74, - ]: - self.enterOuterAlt(localctx, 1) - self.state = 290 - self.scalarType() - pass - elif token in [75, 76, 77, 78, 79, 80]: - self.enterOuterAlt(localctx, 2) - self.state = 291 - self.parameterizedType() - pass - else: - raise NoViableAltException(self) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class ScalarTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_scalarType - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class DateContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def Date(self): - return self.getToken(TestFileParser.Date, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDate"): - listener.enterDate(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDate"): - listener.exitDate(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDate"): - return visitor.visitDate(self) - else: - return visitor.visitChildren(self) - - class StringContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def Str(self): - return self.getToken(TestFileParser.Str, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterString"): - listener.enterString(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitString"): - listener.exitString(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitString"): - return visitor.visitString(self) - else: - return visitor.visitChildren(self) - - class I64Context(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def I64(self): - return self.getToken(TestFileParser.I64, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI64"): - listener.enterI64(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI64"): - listener.exitI64(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI64"): - return visitor.visitI64(self) - else: - return visitor.visitChildren(self) - - class UserDefinedContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def UserDefined(self): - return self.getToken(TestFileParser.UserDefined, 0) - - def IDENTIFIER(self): - return self.getToken(TestFileParser.IDENTIFIER, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUserDefined"): - listener.enterUserDefined(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUserDefined"): - listener.exitUserDefined(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitUserDefined"): - return visitor.visitUserDefined(self) - else: - return visitor.visitChildren(self) - - class I32Context(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def I32(self): - return self.getToken(TestFileParser.I32, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI32"): - listener.enterI32(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI32"): - listener.exitI32(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI32"): - return visitor.visitI32(self) - else: - return visitor.visitChildren(self) - - class IntervalYearContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def IYear(self): - return self.getToken(TestFileParser.IYear, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntervalYear"): - listener.enterIntervalYear(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntervalYear"): - listener.exitIntervalYear(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitIntervalYear"): - return visitor.visitIntervalYear(self) - else: - return visitor.visitChildren(self) - - class UuidContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def UUID(self): - return self.getToken(TestFileParser.UUID, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterUuid"): - listener.enterUuid(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitUuid"): - listener.exitUuid(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitUuid"): - return visitor.visitUuid(self) - else: - return visitor.visitChildren(self) - - class I8Context(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def I8(self): - return self.getToken(TestFileParser.I8, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI8"): - listener.enterI8(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI8"): - listener.exitI8(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI8"): - return visitor.visitI8(self) - else: - return visitor.visitChildren(self) - - class I16Context(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def I16(self): - return self.getToken(TestFileParser.I16, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterI16"): - listener.enterI16(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitI16"): - listener.exitI16(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitI16"): - return visitor.visitI16(self) - else: - return visitor.visitChildren(self) - - class BinaryContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def Binary(self): - return self.getToken(TestFileParser.Binary, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBinary"): - listener.enterBinary(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBinary"): - listener.exitBinary(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitBinary"): - return visitor.visitBinary(self) - else: - return visitor.visitChildren(self) - - class IntervalDayContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def IDay(self): - return self.getToken(TestFileParser.IDay, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntervalDay"): - listener.enterIntervalDay(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntervalDay"): - listener.exitIntervalDay(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitIntervalDay"): - return visitor.visitIntervalDay(self) - else: - return visitor.visitChildren(self) - - class Fp64Context(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def FP64(self): - return self.getToken(TestFileParser.FP64, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFp64"): - listener.enterFp64(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFp64"): - listener.exitFp64(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFp64"): - return visitor.visitFp64(self) - else: - return visitor.visitChildren(self) - - class Fp32Context(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def FP32(self): - return self.getToken(TestFileParser.FP32, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFp32"): - listener.enterFp32(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFp32"): - listener.exitFp32(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFp32"): - return visitor.visitFp32(self) - else: - return visitor.visitChildren(self) - - class TimeContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def Time(self): - return self.getToken(TestFileParser.Time, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTime"): - listener.enterTime(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTime"): - listener.exitTime(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTime"): - return visitor.visitTime(self) - else: - return visitor.visitChildren(self) - - class BooleanContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def Bool(self): - return self.getToken(TestFileParser.Bool, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterBoolean"): - listener.enterBoolean(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitBoolean"): - listener.exitBoolean(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitBoolean"): - return visitor.visitBoolean(self) - else: - return visitor.visitChildren(self) - - class TimestampContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def Ts(self): - return self.getToken(TestFileParser.Ts, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimestamp"): - listener.enterTimestamp(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimestamp"): - listener.exitTimestamp(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTimestamp"): - return visitor.visitTimestamp(self) - else: - return visitor.visitChildren(self) - - class TimestampTzContext(ScalarTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.ScalarTypeContext - super().__init__(parser) - self.copyFrom(ctx) - - def TsTZ(self): - return self.getToken(TestFileParser.TsTZ, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterTimestampTz"): - listener.enterTimestampTz(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitTimestampTz"): - listener.exitTimestampTz(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitTimestampTz"): - return visitor.visitTimestampTz(self) - else: - return visitor.visitChildren(self) - - def scalarType(self): - - localctx = TestFileParser.ScalarTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 62, self.RULE_scalarType) - try: - self.state = 312 - self._errHandler.sync(self) - token = self._input.LA(1) - if token in [68]: - localctx = TestFileParser.BooleanContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 294 - self.match(TestFileParser.Bool) - pass - elif token in [41]: - localctx = TestFileParser.I8Context(self, localctx) - self.enterOuterAlt(localctx, 2) - self.state = 295 - self.match(TestFileParser.I8) - pass - elif token in [42]: - localctx = TestFileParser.I16Context(self, localctx) - self.enterOuterAlt(localctx, 3) - self.state = 296 - self.match(TestFileParser.I16) - pass - elif token in [43]: - localctx = TestFileParser.I32Context(self, localctx) - self.enterOuterAlt(localctx, 4) - self.state = 297 - self.match(TestFileParser.I32) - pass - elif token in [44]: - localctx = TestFileParser.I64Context(self, localctx) - self.enterOuterAlt(localctx, 5) - self.state = 298 - self.match(TestFileParser.I64) - pass - elif token in [45]: - localctx = TestFileParser.Fp32Context(self, localctx) - self.enterOuterAlt(localctx, 6) - self.state = 299 - self.match(TestFileParser.FP32) - pass - elif token in [46]: - localctx = TestFileParser.Fp64Context(self, localctx) - self.enterOuterAlt(localctx, 7) - self.state = 300 - self.match(TestFileParser.FP64) - pass - elif token in [69]: - localctx = TestFileParser.StringContext(self, localctx) - self.enterOuterAlt(localctx, 8) - self.state = 301 - self.match(TestFileParser.Str) - pass - elif token in [48]: - localctx = TestFileParser.BinaryContext(self, localctx) - self.enterOuterAlt(localctx, 9) - self.state = 302 - self.match(TestFileParser.Binary) - pass - elif token in [71]: - localctx = TestFileParser.TimestampContext(self, localctx) - self.enterOuterAlt(localctx, 10) - self.state = 303 - self.match(TestFileParser.Ts) - pass - elif token in [72]: - localctx = TestFileParser.TimestampTzContext(self, localctx) - self.enterOuterAlt(localctx, 11) - self.state = 304 - self.match(TestFileParser.TsTZ) - pass - elif token in [51]: - localctx = TestFileParser.DateContext(self, localctx) - self.enterOuterAlt(localctx, 12) - self.state = 305 - self.match(TestFileParser.Date) - pass - elif token in [52]: - localctx = TestFileParser.TimeContext(self, localctx) - self.enterOuterAlt(localctx, 13) - self.state = 306 - self.match(TestFileParser.Time) - pass - elif token in [74]: - localctx = TestFileParser.IntervalDayContext(self, localctx) - self.enterOuterAlt(localctx, 14) - self.state = 307 - self.match(TestFileParser.IDay) - pass - elif token in [73]: - localctx = TestFileParser.IntervalYearContext(self, localctx) - self.enterOuterAlt(localctx, 15) - self.state = 308 - self.match(TestFileParser.IYear) - pass - elif token in [55]: - localctx = TestFileParser.UuidContext(self, localctx) - self.enterOuterAlt(localctx, 16) - self.state = 309 - self.match(TestFileParser.UUID) - pass - elif token in [67]: - localctx = TestFileParser.UserDefinedContext(self, localctx) - self.enterOuterAlt(localctx, 17) - self.state = 310 - self.match(TestFileParser.UserDefined) - self.state = 311 - self.match(TestFileParser.IDENTIFIER) - pass - else: - raise NoViableAltException(self) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class FixedCharTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_fixedCharType - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class FixedCharContext(FixedCharTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.FixedCharTypeContext - super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext - self.copyFrom(ctx) - - def FChar(self): - return self.getToken(TestFileParser.FChar, 0) - - def O_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) - - def C_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) - - def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) - - def QMARK(self): - return self.getToken(TestFileParser.QMARK, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFixedChar"): - listener.enterFixedChar(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFixedChar"): - listener.exitFixedChar(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFixedChar"): - return visitor.visitFixedChar(self) - else: - return visitor.visitChildren(self) - - def fixedCharType(self): - - localctx = TestFileParser.FixedCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 64, self.RULE_fixedCharType) - self._la = 0 # Token type - try: - localctx = TestFileParser.FixedCharContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 314 - self.match(TestFileParser.FChar) - self.state = 316 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 92: - self.state = 315 - localctx.isnull = self.match(TestFileParser.QMARK) - - self.state = 318 - self.match(TestFileParser.O_ANGLE_BRACKET) - self.state = 319 - localctx.len_ = self.numericParameter() - self.state = 320 - self.match(TestFileParser.C_ANGLE_BRACKET) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class VarCharTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_varCharType - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class VarCharContext(VarCharTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.VarCharTypeContext - super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext - self.copyFrom(ctx) - - def VChar(self): - return self.getToken(TestFileParser.VChar, 0) - - def O_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) - - def C_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) - - def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) - - def QMARK(self): - return self.getToken(TestFileParser.QMARK, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterVarChar"): - listener.enterVarChar(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitVarChar"): - listener.exitVarChar(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitVarChar"): - return visitor.visitVarChar(self) - else: - return visitor.visitChildren(self) - - def varCharType(self): - - localctx = TestFileParser.VarCharTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 66, self.RULE_varCharType) - self._la = 0 # Token type - try: - localctx = TestFileParser.VarCharContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 322 - self.match(TestFileParser.VChar) - self.state = 324 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 92: - self.state = 323 - localctx.isnull = self.match(TestFileParser.QMARK) - - self.state = 326 - self.match(TestFileParser.O_ANGLE_BRACKET) - self.state = 327 - localctx.len_ = self.numericParameter() - self.state = 328 - self.match(TestFileParser.C_ANGLE_BRACKET) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class FixedBinaryTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_fixedBinaryType - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class FixedBinaryContext(FixedBinaryTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.FixedBinaryTypeContext - super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext - self.copyFrom(ctx) - - def FBin(self): - return self.getToken(TestFileParser.FBin, 0) - - def O_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) - - def C_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) - - def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) - - def QMARK(self): - return self.getToken(TestFileParser.QMARK, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFixedBinary"): - listener.enterFixedBinary(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFixedBinary"): - listener.exitFixedBinary(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFixedBinary"): - return visitor.visitFixedBinary(self) - else: - return visitor.visitChildren(self) - - def fixedBinaryType(self): - - localctx = TestFileParser.FixedBinaryTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 68, self.RULE_fixedBinaryType) - self._la = 0 # Token type - try: - localctx = TestFileParser.FixedBinaryContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 330 - self.match(TestFileParser.FBin) - self.state = 332 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 92: - self.state = 331 - localctx.isnull = self.match(TestFileParser.QMARK) - - self.state = 334 - self.match(TestFileParser.O_ANGLE_BRACKET) - self.state = 335 - localctx.len_ = self.numericParameter() - self.state = 336 - self.match(TestFileParser.C_ANGLE_BRACKET) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class DecimalTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_decimalType - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class DecimalContext(DecimalTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.DecimalTypeContext - super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext - self.scale = None # NumericParameterContext - self.copyFrom(ctx) - - def Dec(self): - return self.getToken(TestFileParser.Dec, 0) - - def O_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) - - def COMMA(self): - return self.getToken(TestFileParser.COMMA, 0) - - def C_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) - - def QMARK(self): - return self.getToken(TestFileParser.QMARK, 0) - - def numericParameter(self, i: int = None): - if i is None: - return self.getTypedRuleContexts(TestFileParser.NumericParameterContext) - else: - return self.getTypedRuleContext( - TestFileParser.NumericParameterContext, i - ) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterDecimal"): - listener.enterDecimal(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitDecimal"): - listener.exitDecimal(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitDecimal"): - return visitor.visitDecimal(self) - else: - return visitor.visitChildren(self) - - def decimalType(self): - - localctx = TestFileParser.DecimalTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 70, self.RULE_decimalType) - self._la = 0 # Token type - try: - localctx = TestFileParser.DecimalContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 338 - self.match(TestFileParser.Dec) - self.state = 340 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 92: - self.state = 339 - localctx.isnull = self.match(TestFileParser.QMARK) - - self.state = 348 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 83: - self.state = 342 - self.match(TestFileParser.O_ANGLE_BRACKET) - self.state = 343 - localctx.precision = self.numericParameter() - self.state = 344 - self.match(TestFileParser.COMMA) - self.state = 345 - localctx.scale = self.numericParameter() - self.state = 346 - self.match(TestFileParser.C_ANGLE_BRACKET) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class PrecisionTimestampTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_precisionTimestampType - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class PrecisionTimestampContext(PrecisionTimestampTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.PrecisionTimestampTypeContext - super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext - self.copyFrom(ctx) - - def PTs(self): - return self.getToken(TestFileParser.PTs, 0) - - def O_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) - - def C_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) - - def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) - - def QMARK(self): - return self.getToken(TestFileParser.QMARK, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterPrecisionTimestamp"): - listener.enterPrecisionTimestamp(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitPrecisionTimestamp"): - listener.exitPrecisionTimestamp(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitPrecisionTimestamp"): - return visitor.visitPrecisionTimestamp(self) - else: - return visitor.visitChildren(self) - - def precisionTimestampType(self): - - localctx = TestFileParser.PrecisionTimestampTypeContext( - self, self._ctx, self.state - ) - self.enterRule(localctx, 72, self.RULE_precisionTimestampType) - self._la = 0 # Token type - try: - localctx = TestFileParser.PrecisionTimestampContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 350 - self.match(TestFileParser.PTs) - self.state = 352 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 92: - self.state = 351 - localctx.isnull = self.match(TestFileParser.QMARK) - - self.state = 354 - self.match(TestFileParser.O_ANGLE_BRACKET) - self.state = 355 - localctx.precision = self.numericParameter() - self.state = 356 - self.match(TestFileParser.C_ANGLE_BRACKET) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class PrecisionTimestampTZTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_precisionTimestampTZType - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class PrecisionTimestampTZContext(PrecisionTimestampTZTypeContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.PrecisionTimestampTZTypeContext - super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext - self.copyFrom(ctx) - - def PTsTZ(self): - return self.getToken(TestFileParser.PTsTZ, 0) - - def O_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.O_ANGLE_BRACKET, 0) - - def C_ANGLE_BRACKET(self): - return self.getToken(TestFileParser.C_ANGLE_BRACKET, 0) - - def numericParameter(self): - return self.getTypedRuleContext(TestFileParser.NumericParameterContext, 0) - - def QMARK(self): - return self.getToken(TestFileParser.QMARK, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterPrecisionTimestampTZ"): - listener.enterPrecisionTimestampTZ(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitPrecisionTimestampTZ"): - listener.exitPrecisionTimestampTZ(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitPrecisionTimestampTZ"): - return visitor.visitPrecisionTimestampTZ(self) - else: - return visitor.visitChildren(self) - - def precisionTimestampTZType(self): - - localctx = TestFileParser.PrecisionTimestampTZTypeContext( - self, self._ctx, self.state - ) - self.enterRule(localctx, 74, self.RULE_precisionTimestampTZType) - self._la = 0 # Token type - try: - localctx = TestFileParser.PrecisionTimestampTZContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 358 - self.match(TestFileParser.PTsTZ) - self.state = 360 - self._errHandler.sync(self) - _la = self._input.LA(1) - if _la == 92: - self.state = 359 - localctx.isnull = self.match(TestFileParser.QMARK) - - self.state = 362 - self.match(TestFileParser.O_ANGLE_BRACKET) - self.state = 363 - localctx.precision = self.numericParameter() - self.state = 364 - self.match(TestFileParser.C_ANGLE_BRACKET) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class ParameterizedTypeContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def fixedCharType(self): - return self.getTypedRuleContext(TestFileParser.FixedCharTypeContext, 0) - - def varCharType(self): - return self.getTypedRuleContext(TestFileParser.VarCharTypeContext, 0) - - def fixedBinaryType(self): - return self.getTypedRuleContext(TestFileParser.FixedBinaryTypeContext, 0) - - def decimalType(self): - return self.getTypedRuleContext(TestFileParser.DecimalTypeContext, 0) - - def precisionTimestampType(self): - return self.getTypedRuleContext( - TestFileParser.PrecisionTimestampTypeContext, 0 - ) - - def precisionTimestampTZType(self): - return self.getTypedRuleContext( - TestFileParser.PrecisionTimestampTZTypeContext, 0 - ) - - def getRuleIndex(self): - return TestFileParser.RULE_parameterizedType - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterParameterizedType"): - listener.enterParameterizedType(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitParameterizedType"): - listener.exitParameterizedType(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitParameterizedType"): - return visitor.visitParameterizedType(self) - else: - return visitor.visitChildren(self) - - def parameterizedType(self): - - localctx = TestFileParser.ParameterizedTypeContext(self, self._ctx, self.state) - self.enterRule(localctx, 76, self.RULE_parameterizedType) - try: - self.state = 372 - self._errHandler.sync(self) - token = self._input.LA(1) - if token in [78]: - self.enterOuterAlt(localctx, 1) - self.state = 366 - self.fixedCharType() - pass - elif token in [79]: - self.enterOuterAlt(localctx, 2) - self.state = 367 - self.varCharType() - pass - elif token in [80]: - self.enterOuterAlt(localctx, 3) - self.state = 368 - self.fixedBinaryType() - pass - elif token in [75]: - self.enterOuterAlt(localctx, 4) - self.state = 369 - self.decimalType() - pass - elif token in [76]: - self.enterOuterAlt(localctx, 5) - self.state = 370 - self.precisionTimestampType() - pass - elif token in [77]: - self.enterOuterAlt(localctx, 6) - self.state = 371 - self.precisionTimestampTZType() - pass - else: - raise NoViableAltException(self) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class NumericParameterContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def getRuleIndex(self): - return TestFileParser.RULE_numericParameter - - def copyFrom(self, ctx: ParserRuleContext): - super().copyFrom(ctx) - - class IntegerLiteralContext(NumericParameterContext): - def __init__( - self, parser, ctx: ParserRuleContext - ): # actually a TestFileParser.NumericParameterContext - super().__init__(parser) - self.copyFrom(ctx) - - def INTEGER_LITERAL(self): - return self.getToken(TestFileParser.INTEGER_LITERAL, 0) - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterIntegerLiteral"): - listener.enterIntegerLiteral(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitIntegerLiteral"): - listener.exitIntegerLiteral(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitIntegerLiteral"): - return visitor.visitIntegerLiteral(self) - else: - return visitor.visitChildren(self) - - def numericParameter(self): - - localctx = TestFileParser.NumericParameterContext(self, self._ctx, self.state) - self.enterRule(localctx, 78, self.RULE_numericParameter) - try: - localctx = TestFileParser.IntegerLiteralContext(self, localctx) - self.enterOuterAlt(localctx, 1) - self.state = 374 - self.match(TestFileParser.INTEGER_LITERAL) - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class SubstraitErrorContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def ERROR_RESULT(self): - return self.getToken(TestFileParser.ERROR_RESULT, 0) - - def UNDEFINED_RESULT(self): - return self.getToken(TestFileParser.UNDEFINED_RESULT, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_substraitError - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterSubstraitError"): - listener.enterSubstraitError(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitSubstraitError"): - listener.exitSubstraitError(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitSubstraitError"): - return visitor.visitSubstraitError(self) - else: - return visitor.visitChildren(self) - - def substraitError(self): - - localctx = TestFileParser.SubstraitErrorContext(self, self._ctx, self.state) - self.enterRule(localctx, 80, self.RULE_substraitError) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 376 - _la = self._input.LA(1) - if not (_la == 5 or _la == 6): - self._errHandler.recoverInline(self) - else: - self._errHandler.reportMatch(self) - self.consume() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class Func_optionContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def option_name(self): - return self.getTypedRuleContext(TestFileParser.Option_nameContext, 0) - - def COLON(self): - return self.getToken(TestFileParser.COLON, 0) - - def option_value(self): - return self.getTypedRuleContext(TestFileParser.Option_valueContext, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_func_option - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFunc_option"): - listener.enterFunc_option(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFunc_option"): - listener.exitFunc_option(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFunc_option"): - return visitor.visitFunc_option(self) - else: - return visitor.visitChildren(self) - - def func_option(self): - - localctx = TestFileParser.Func_optionContext(self, self._ctx, self.state) - self.enterRule(localctx, 82, self.RULE_func_option) - try: - self.enterOuterAlt(localctx, 1) - self.state = 378 - self.option_name() - self.state = 379 - self.match(TestFileParser.COLON) - self.state = 380 - self.option_value() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class Option_nameContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def OVERFLOW(self): - return self.getToken(TestFileParser.OVERFLOW, 0) - - def ROUNDING(self): - return self.getToken(TestFileParser.ROUNDING, 0) - - def IDENTIFIER(self): - return self.getToken(TestFileParser.IDENTIFIER, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_option_name - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOption_name"): - listener.enterOption_name(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOption_name"): - listener.exitOption_name(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitOption_name"): - return visitor.visitOption_name(self) - else: - return visitor.visitChildren(self) - - def option_name(self): - - localctx = TestFileParser.Option_nameContext(self, self._ctx, self.state) - self.enterRule(localctx, 84, self.RULE_option_name) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 382 - _la = self._input.LA(1) - if not (_la == 7 or _la == 8 or _la == 82): - self._errHandler.recoverInline(self) - else: - self._errHandler.reportMatch(self) - self.consume() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class Option_valueContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def ERROR(self): - return self.getToken(TestFileParser.ERROR, 0) - - def SATURATE(self): - return self.getToken(TestFileParser.SATURATE, 0) - - def SILENT(self): - return self.getToken(TestFileParser.SILENT, 0) - - def TIE_TO_EVEN(self): - return self.getToken(TestFileParser.TIE_TO_EVEN, 0) - - def NAN(self): - return self.getToken(TestFileParser.NAN, 0) - - def getRuleIndex(self): - return TestFileParser.RULE_option_value - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterOption_value"): - listener.enterOption_value(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitOption_value"): - listener.exitOption_value(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitOption_value"): - return visitor.visitOption_value(self) - else: - return visitor.visitChildren(self) - - def option_value(self): - - localctx = TestFileParser.Option_valueContext(self, self._ctx, self.state) - self.enterRule(localctx, 86, self.RULE_option_value) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 384 - _la = self._input.LA(1) - if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 15872) != 0)): - self._errHandler.recoverInline(self) - else: - self._errHandler.reportMatch(self) - self.consume() - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx - - class Func_optionsContext(ParserRuleContext): - __slots__ = "parser" - - def __init__( - self, parser, parent: ParserRuleContext = None, invokingState: int = -1 - ): - super().__init__(parent, invokingState) - self.parser = parser - - def func_option(self, i: int = None): - if i is None: - return self.getTypedRuleContexts(TestFileParser.Func_optionContext) - else: - return self.getTypedRuleContext(TestFileParser.Func_optionContext, i) - - def COMMA(self, i: int = None): - if i is None: - return self.getTokens(TestFileParser.COMMA) - else: - return self.getToken(TestFileParser.COMMA, i) - - def getRuleIndex(self): - return TestFileParser.RULE_func_options - - def enterRule(self, listener: ParseTreeListener): - if hasattr(listener, "enterFunc_options"): - listener.enterFunc_options(self) - - def exitRule(self, listener: ParseTreeListener): - if hasattr(listener, "exitFunc_options"): - listener.exitFunc_options(self) - - def accept(self, visitor: ParseTreeVisitor): - if hasattr(visitor, "visitFunc_options"): - return visitor.visitFunc_options(self) - else: - return visitor.visitChildren(self) - - def func_options(self): - - localctx = TestFileParser.Func_optionsContext(self, self._ctx, self.state) - self.enterRule(localctx, 88, self.RULE_func_options) - self._la = 0 # Token type - try: - self.enterOuterAlt(localctx, 1) - self.state = 386 - self.func_option() - self.state = 391 - self._errHandler.sync(self) - _la = self._input.LA(1) - while _la == 89: - self.state = 387 - self.match(TestFileParser.COMMA) - self.state = 388 - self.func_option() - self.state = 393 - self._errHandler.sync(self) - _la = self._input.LA(1) - - except RecognitionException as re: - localctx.exception = re - self._errHandler.reportError(self, re) - self._errHandler.recover(self, re) - finally: - self.exitRule() - return localctx diff --git a/tests/coverage/antlr_parser/TestFileParserListener.py b/tests/coverage/antlr_parser/TestFileParserListener.py deleted file mode 100644 index 68f946545..000000000 --- a/tests/coverage/antlr_parser/TestFileParserListener.py +++ /dev/null @@ -1,507 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -# Generated from TestFileParser.g4 by ANTLR 4.13.2 -from antlr4 import ParseTreeListener - -if "." in __name__: - from .TestFileParser import TestFileParser -else: - from TestFileParser import TestFileParser - - -# This class defines a complete listener for a parse tree produced by TestFileParser. -class TestFileParserListener(ParseTreeListener): - - # Enter a parse tree produced by TestFileParser#doc. - def enterDoc(self, ctx: TestFileParser.DocContext): - pass - - # Exit a parse tree produced by TestFileParser#doc. - def exitDoc(self, ctx: TestFileParser.DocContext): - pass - - # Enter a parse tree produced by TestFileParser#header. - def enterHeader(self, ctx: TestFileParser.HeaderContext): - pass - - # Exit a parse tree produced by TestFileParser#header. - def exitHeader(self, ctx: TestFileParser.HeaderContext): - pass - - # Enter a parse tree produced by TestFileParser#version. - def enterVersion(self, ctx: TestFileParser.VersionContext): - pass - - # Exit a parse tree produced by TestFileParser#version. - def exitVersion(self, ctx: TestFileParser.VersionContext): - pass - - # Enter a parse tree produced by TestFileParser#include. - def enterInclude(self, ctx: TestFileParser.IncludeContext): - pass - - # Exit a parse tree produced by TestFileParser#include. - def exitInclude(self, ctx: TestFileParser.IncludeContext): - pass - - # Enter a parse tree produced by TestFileParser#testGroupDescription. - def enterTestGroupDescription( - self, ctx: TestFileParser.TestGroupDescriptionContext - ): - pass - - # Exit a parse tree produced by TestFileParser#testGroupDescription. - def exitTestGroupDescription(self, ctx: TestFileParser.TestGroupDescriptionContext): - pass - - # Enter a parse tree produced by TestFileParser#testCase. - def enterTestCase(self, ctx: TestFileParser.TestCaseContext): - pass - - # Exit a parse tree produced by TestFileParser#testCase. - def exitTestCase(self, ctx: TestFileParser.TestCaseContext): - pass - - # Enter a parse tree produced by TestFileParser#testGroup. - def enterTestGroup(self, ctx: TestFileParser.TestGroupContext): - pass - - # Exit a parse tree produced by TestFileParser#testGroup. - def exitTestGroup(self, ctx: TestFileParser.TestGroupContext): - pass - - # Enter a parse tree produced by TestFileParser#arguments. - def enterArguments(self, ctx: TestFileParser.ArgumentsContext): - pass - - # Exit a parse tree produced by TestFileParser#arguments. - def exitArguments(self, ctx: TestFileParser.ArgumentsContext): - pass - - # Enter a parse tree produced by TestFileParser#result. - def enterResult(self, ctx: TestFileParser.ResultContext): - pass - - # Exit a parse tree produced by TestFileParser#result. - def exitResult(self, ctx: TestFileParser.ResultContext): - pass - - # Enter a parse tree produced by TestFileParser#argument. - def enterArgument(self, ctx: TestFileParser.ArgumentContext): - pass - - # Exit a parse tree produced by TestFileParser#argument. - def exitArgument(self, ctx: TestFileParser.ArgumentContext): - pass - - # Enter a parse tree produced by TestFileParser#numericLiteral. - def enterNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): - pass - - # Exit a parse tree produced by TestFileParser#numericLiteral. - def exitNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): - pass - - # Enter a parse tree produced by TestFileParser#nullArg. - def enterNullArg(self, ctx: TestFileParser.NullArgContext): - pass - - # Exit a parse tree produced by TestFileParser#nullArg. - def exitNullArg(self, ctx: TestFileParser.NullArgContext): - pass - - # Enter a parse tree produced by TestFileParser#i8Arg. - def enterI8Arg(self, ctx: TestFileParser.I8ArgContext): - pass - - # Exit a parse tree produced by TestFileParser#i8Arg. - def exitI8Arg(self, ctx: TestFileParser.I8ArgContext): - pass - - # Enter a parse tree produced by TestFileParser#i16Arg. - def enterI16Arg(self, ctx: TestFileParser.I16ArgContext): - pass - - # Exit a parse tree produced by TestFileParser#i16Arg. - def exitI16Arg(self, ctx: TestFileParser.I16ArgContext): - pass - - # Enter a parse tree produced by TestFileParser#i32Arg. - def enterI32Arg(self, ctx: TestFileParser.I32ArgContext): - pass - - # Exit a parse tree produced by TestFileParser#i32Arg. - def exitI32Arg(self, ctx: TestFileParser.I32ArgContext): - pass - - # Enter a parse tree produced by TestFileParser#i64Arg. - def enterI64Arg(self, ctx: TestFileParser.I64ArgContext): - pass - - # Exit a parse tree produced by TestFileParser#i64Arg. - def exitI64Arg(self, ctx: TestFileParser.I64ArgContext): - pass - - # Enter a parse tree produced by TestFileParser#fp32Arg. - def enterFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): - pass - - # Exit a parse tree produced by TestFileParser#fp32Arg. - def exitFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): - pass - - # Enter a parse tree produced by TestFileParser#fp64Arg. - def enterFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): - pass - - # Exit a parse tree produced by TestFileParser#fp64Arg. - def exitFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): - pass - - # Enter a parse tree produced by TestFileParser#decimalArg. - def enterDecimalArg(self, ctx: TestFileParser.DecimalArgContext): - pass - - # Exit a parse tree produced by TestFileParser#decimalArg. - def exitDecimalArg(self, ctx: TestFileParser.DecimalArgContext): - pass - - # Enter a parse tree produced by TestFileParser#booleanArg. - def enterBooleanArg(self, ctx: TestFileParser.BooleanArgContext): - pass - - # Exit a parse tree produced by TestFileParser#booleanArg. - def exitBooleanArg(self, ctx: TestFileParser.BooleanArgContext): - pass - - # Enter a parse tree produced by TestFileParser#stringArg. - def enterStringArg(self, ctx: TestFileParser.StringArgContext): - pass - - # Exit a parse tree produced by TestFileParser#stringArg. - def exitStringArg(self, ctx: TestFileParser.StringArgContext): - pass - - # Enter a parse tree produced by TestFileParser#dateArg. - def enterDateArg(self, ctx: TestFileParser.DateArgContext): - pass - - # Exit a parse tree produced by TestFileParser#dateArg. - def exitDateArg(self, ctx: TestFileParser.DateArgContext): - pass - - # Enter a parse tree produced by TestFileParser#timeArg. - def enterTimeArg(self, ctx: TestFileParser.TimeArgContext): - pass - - # Exit a parse tree produced by TestFileParser#timeArg. - def exitTimeArg(self, ctx: TestFileParser.TimeArgContext): - pass - - # Enter a parse tree produced by TestFileParser#timestampArg. - def enterTimestampArg(self, ctx: TestFileParser.TimestampArgContext): - pass - - # Exit a parse tree produced by TestFileParser#timestampArg. - def exitTimestampArg(self, ctx: TestFileParser.TimestampArgContext): - pass - - # Enter a parse tree produced by TestFileParser#timestampTzArg. - def enterTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): - pass - - # Exit a parse tree produced by TestFileParser#timestampTzArg. - def exitTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): - pass - - # Enter a parse tree produced by TestFileParser#intervalYearArg. - def enterIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): - pass - - # Exit a parse tree produced by TestFileParser#intervalYearArg. - def exitIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): - pass - - # Enter a parse tree produced by TestFileParser#intervalDayArg. - def enterIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): - pass - - # Exit a parse tree produced by TestFileParser#intervalDayArg. - def exitIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): - pass - - # Enter a parse tree produced by TestFileParser#intervalYearLiteral. - def enterIntervalYearLiteral(self, ctx: TestFileParser.IntervalYearLiteralContext): - pass - - # Exit a parse tree produced by TestFileParser#intervalYearLiteral. - def exitIntervalYearLiteral(self, ctx: TestFileParser.IntervalYearLiteralContext): - pass - - # Enter a parse tree produced by TestFileParser#intervalDayLiteral. - def enterIntervalDayLiteral(self, ctx: TestFileParser.IntervalDayLiteralContext): - pass - - # Exit a parse tree produced by TestFileParser#intervalDayLiteral. - def exitIntervalDayLiteral(self, ctx: TestFileParser.IntervalDayLiteralContext): - pass - - # Enter a parse tree produced by TestFileParser#timeInterval. - def enterTimeInterval(self, ctx: TestFileParser.TimeIntervalContext): - pass - - # Exit a parse tree produced by TestFileParser#timeInterval. - def exitTimeInterval(self, ctx: TestFileParser.TimeIntervalContext): - pass - - # Enter a parse tree produced by TestFileParser#datatype. - def enterDatatype(self, ctx: TestFileParser.DatatypeContext): - pass - - # Exit a parse tree produced by TestFileParser#datatype. - def exitDatatype(self, ctx: TestFileParser.DatatypeContext): - pass - - # Enter a parse tree produced by TestFileParser#Boolean. - def enterBoolean(self, ctx: TestFileParser.BooleanContext): - pass - - # Exit a parse tree produced by TestFileParser#Boolean. - def exitBoolean(self, ctx: TestFileParser.BooleanContext): - pass - - # Enter a parse tree produced by TestFileParser#i8. - def enterI8(self, ctx: TestFileParser.I8Context): - pass - - # Exit a parse tree produced by TestFileParser#i8. - def exitI8(self, ctx: TestFileParser.I8Context): - pass - - # Enter a parse tree produced by TestFileParser#i16. - def enterI16(self, ctx: TestFileParser.I16Context): - pass - - # Exit a parse tree produced by TestFileParser#i16. - def exitI16(self, ctx: TestFileParser.I16Context): - pass - - # Enter a parse tree produced by TestFileParser#i32. - def enterI32(self, ctx: TestFileParser.I32Context): - pass - - # Exit a parse tree produced by TestFileParser#i32. - def exitI32(self, ctx: TestFileParser.I32Context): - pass - - # Enter a parse tree produced by TestFileParser#i64. - def enterI64(self, ctx: TestFileParser.I64Context): - pass - - # Exit a parse tree produced by TestFileParser#i64. - def exitI64(self, ctx: TestFileParser.I64Context): - pass - - # Enter a parse tree produced by TestFileParser#fp32. - def enterFp32(self, ctx: TestFileParser.Fp32Context): - pass - - # Exit a parse tree produced by TestFileParser#fp32. - def exitFp32(self, ctx: TestFileParser.Fp32Context): - pass - - # Enter a parse tree produced by TestFileParser#fp64. - def enterFp64(self, ctx: TestFileParser.Fp64Context): - pass - - # Exit a parse tree produced by TestFileParser#fp64. - def exitFp64(self, ctx: TestFileParser.Fp64Context): - pass - - # Enter a parse tree produced by TestFileParser#string. - def enterString(self, ctx: TestFileParser.StringContext): - pass - - # Exit a parse tree produced by TestFileParser#string. - def exitString(self, ctx: TestFileParser.StringContext): - pass - - # Enter a parse tree produced by TestFileParser#binary. - def enterBinary(self, ctx: TestFileParser.BinaryContext): - pass - - # Exit a parse tree produced by TestFileParser#binary. - def exitBinary(self, ctx: TestFileParser.BinaryContext): - pass - - # Enter a parse tree produced by TestFileParser#timestamp. - def enterTimestamp(self, ctx: TestFileParser.TimestampContext): - pass - - # Exit a parse tree produced by TestFileParser#timestamp. - def exitTimestamp(self, ctx: TestFileParser.TimestampContext): - pass - - # Enter a parse tree produced by TestFileParser#timestampTz. - def enterTimestampTz(self, ctx: TestFileParser.TimestampTzContext): - pass - - # Exit a parse tree produced by TestFileParser#timestampTz. - def exitTimestampTz(self, ctx: TestFileParser.TimestampTzContext): - pass - - # Enter a parse tree produced by TestFileParser#date. - def enterDate(self, ctx: TestFileParser.DateContext): - pass - - # Exit a parse tree produced by TestFileParser#date. - def exitDate(self, ctx: TestFileParser.DateContext): - pass - - # Enter a parse tree produced by TestFileParser#time. - def enterTime(self, ctx: TestFileParser.TimeContext): - pass - - # Exit a parse tree produced by TestFileParser#time. - def exitTime(self, ctx: TestFileParser.TimeContext): - pass - - # Enter a parse tree produced by TestFileParser#intervalDay. - def enterIntervalDay(self, ctx: TestFileParser.IntervalDayContext): - pass - - # Exit a parse tree produced by TestFileParser#intervalDay. - def exitIntervalDay(self, ctx: TestFileParser.IntervalDayContext): - pass - - # Enter a parse tree produced by TestFileParser#intervalYear. - def enterIntervalYear(self, ctx: TestFileParser.IntervalYearContext): - pass - - # Exit a parse tree produced by TestFileParser#intervalYear. - def exitIntervalYear(self, ctx: TestFileParser.IntervalYearContext): - pass - - # Enter a parse tree produced by TestFileParser#uuid. - def enterUuid(self, ctx: TestFileParser.UuidContext): - pass - - # Exit a parse tree produced by TestFileParser#uuid. - def exitUuid(self, ctx: TestFileParser.UuidContext): - pass - - # Enter a parse tree produced by TestFileParser#userDefined. - def enterUserDefined(self, ctx: TestFileParser.UserDefinedContext): - pass - - # Exit a parse tree produced by TestFileParser#userDefined. - def exitUserDefined(self, ctx: TestFileParser.UserDefinedContext): - pass - - # Enter a parse tree produced by TestFileParser#fixedChar. - def enterFixedChar(self, ctx: TestFileParser.FixedCharContext): - pass - - # Exit a parse tree produced by TestFileParser#fixedChar. - def exitFixedChar(self, ctx: TestFileParser.FixedCharContext): - pass - - # Enter a parse tree produced by TestFileParser#varChar. - def enterVarChar(self, ctx: TestFileParser.VarCharContext): - pass - - # Exit a parse tree produced by TestFileParser#varChar. - def exitVarChar(self, ctx: TestFileParser.VarCharContext): - pass - - # Enter a parse tree produced by TestFileParser#fixedBinary. - def enterFixedBinary(self, ctx: TestFileParser.FixedBinaryContext): - pass - - # Exit a parse tree produced by TestFileParser#fixedBinary. - def exitFixedBinary(self, ctx: TestFileParser.FixedBinaryContext): - pass - - # Enter a parse tree produced by TestFileParser#decimal. - def enterDecimal(self, ctx: TestFileParser.DecimalContext): - pass - - # Exit a parse tree produced by TestFileParser#decimal. - def exitDecimal(self, ctx: TestFileParser.DecimalContext): - pass - - # Enter a parse tree produced by TestFileParser#precisionTimestamp. - def enterPrecisionTimestamp(self, ctx: TestFileParser.PrecisionTimestampContext): - pass - - # Exit a parse tree produced by TestFileParser#precisionTimestamp. - def exitPrecisionTimestamp(self, ctx: TestFileParser.PrecisionTimestampContext): - pass - - # Enter a parse tree produced by TestFileParser#precisionTimestampTZ. - def enterPrecisionTimestampTZ( - self, ctx: TestFileParser.PrecisionTimestampTZContext - ): - pass - - # Exit a parse tree produced by TestFileParser#precisionTimestampTZ. - def exitPrecisionTimestampTZ(self, ctx: TestFileParser.PrecisionTimestampTZContext): - pass - - # Enter a parse tree produced by TestFileParser#parameterizedType. - def enterParameterizedType(self, ctx: TestFileParser.ParameterizedTypeContext): - pass - - # Exit a parse tree produced by TestFileParser#parameterizedType. - def exitParameterizedType(self, ctx: TestFileParser.ParameterizedTypeContext): - pass - - # Enter a parse tree produced by TestFileParser#integerLiteral. - def enterIntegerLiteral(self, ctx: TestFileParser.IntegerLiteralContext): - pass - - # Exit a parse tree produced by TestFileParser#integerLiteral. - def exitIntegerLiteral(self, ctx: TestFileParser.IntegerLiteralContext): - pass - - # Enter a parse tree produced by TestFileParser#substraitError. - def enterSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): - pass - - # Exit a parse tree produced by TestFileParser#substraitError. - def exitSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): - pass - - # Enter a parse tree produced by TestFileParser#func_option. - def enterFunc_option(self, ctx: TestFileParser.Func_optionContext): - pass - - # Exit a parse tree produced by TestFileParser#func_option. - def exitFunc_option(self, ctx: TestFileParser.Func_optionContext): - pass - - # Enter a parse tree produced by TestFileParser#option_name. - def enterOption_name(self, ctx: TestFileParser.Option_nameContext): - pass - - # Exit a parse tree produced by TestFileParser#option_name. - def exitOption_name(self, ctx: TestFileParser.Option_nameContext): - pass - - # Enter a parse tree produced by TestFileParser#option_value. - def enterOption_value(self, ctx: TestFileParser.Option_valueContext): - pass - - # Exit a parse tree produced by TestFileParser#option_value. - def exitOption_value(self, ctx: TestFileParser.Option_valueContext): - pass - - # Enter a parse tree produced by TestFileParser#func_options. - def enterFunc_options(self, ctx: TestFileParser.Func_optionsContext): - pass - - # Exit a parse tree produced by TestFileParser#func_options. - def exitFunc_options(self, ctx: TestFileParser.Func_optionsContext): - pass - - -del TestFileParser diff --git a/tests/coverage/antlr_parser/TestFileParserVisitor.py b/tests/coverage/antlr_parser/TestFileParserVisitor.py deleted file mode 100644 index 2a4c74dc2..000000000 --- a/tests/coverage/antlr_parser/TestFileParserVisitor.py +++ /dev/null @@ -1,264 +0,0 @@ -# SPDX-License-Identifier: Apache-2.0 -# Generated from TestFileParser.g4 by ANTLR 4.13.2 -from antlr4 import ParseTreeVisitor - -if "." in __name__: - from .TestFileParser import TestFileParser -else: - from TestFileParser import TestFileParser - -# This class defines a complete generic visitor for a parse tree produced by TestFileParser. - - -class TestFileParserVisitor(ParseTreeVisitor): - - # Visit a parse tree produced by TestFileParser#doc. - def visitDoc(self, ctx: TestFileParser.DocContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#header. - def visitHeader(self, ctx: TestFileParser.HeaderContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#version. - def visitVersion(self, ctx: TestFileParser.VersionContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#include. - def visitInclude(self, ctx: TestFileParser.IncludeContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#testGroupDescription. - def visitTestGroupDescription( - self, ctx: TestFileParser.TestGroupDescriptionContext - ): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#testCase. - def visitTestCase(self, ctx: TestFileParser.TestCaseContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#testGroup. - def visitTestGroup(self, ctx: TestFileParser.TestGroupContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#arguments. - def visitArguments(self, ctx: TestFileParser.ArgumentsContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#result. - def visitResult(self, ctx: TestFileParser.ResultContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#argument. - def visitArgument(self, ctx: TestFileParser.ArgumentContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#numericLiteral. - def visitNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#nullArg. - def visitNullArg(self, ctx: TestFileParser.NullArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i8Arg. - def visitI8Arg(self, ctx: TestFileParser.I8ArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i16Arg. - def visitI16Arg(self, ctx: TestFileParser.I16ArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i32Arg. - def visitI32Arg(self, ctx: TestFileParser.I32ArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i64Arg. - def visitI64Arg(self, ctx: TestFileParser.I64ArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#fp32Arg. - def visitFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#fp64Arg. - def visitFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#decimalArg. - def visitDecimalArg(self, ctx: TestFileParser.DecimalArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#booleanArg. - def visitBooleanArg(self, ctx: TestFileParser.BooleanArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#stringArg. - def visitStringArg(self, ctx: TestFileParser.StringArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#dateArg. - def visitDateArg(self, ctx: TestFileParser.DateArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#timeArg. - def visitTimeArg(self, ctx: TestFileParser.TimeArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#timestampArg. - def visitTimestampArg(self, ctx: TestFileParser.TimestampArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#timestampTzArg. - def visitTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#intervalYearArg. - def visitIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#intervalDayArg. - def visitIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#intervalYearLiteral. - def visitIntervalYearLiteral(self, ctx: TestFileParser.IntervalYearLiteralContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#intervalDayLiteral. - def visitIntervalDayLiteral(self, ctx: TestFileParser.IntervalDayLiteralContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#timeInterval. - def visitTimeInterval(self, ctx: TestFileParser.TimeIntervalContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#datatype. - def visitDatatype(self, ctx: TestFileParser.DatatypeContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#Boolean. - def visitBoolean(self, ctx: TestFileParser.BooleanContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i8. - def visitI8(self, ctx: TestFileParser.I8Context): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i16. - def visitI16(self, ctx: TestFileParser.I16Context): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i32. - def visitI32(self, ctx: TestFileParser.I32Context): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#i64. - def visitI64(self, ctx: TestFileParser.I64Context): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#fp32. - def visitFp32(self, ctx: TestFileParser.Fp32Context): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#fp64. - def visitFp64(self, ctx: TestFileParser.Fp64Context): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#string. - def visitString(self, ctx: TestFileParser.StringContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#binary. - def visitBinary(self, ctx: TestFileParser.BinaryContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#timestamp. - def visitTimestamp(self, ctx: TestFileParser.TimestampContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#timestampTz. - def visitTimestampTz(self, ctx: TestFileParser.TimestampTzContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#date. - def visitDate(self, ctx: TestFileParser.DateContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#time. - def visitTime(self, ctx: TestFileParser.TimeContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#intervalDay. - def visitIntervalDay(self, ctx: TestFileParser.IntervalDayContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#intervalYear. - def visitIntervalYear(self, ctx: TestFileParser.IntervalYearContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#uuid. - def visitUuid(self, ctx: TestFileParser.UuidContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#userDefined. - def visitUserDefined(self, ctx: TestFileParser.UserDefinedContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#fixedChar. - def visitFixedChar(self, ctx: TestFileParser.FixedCharContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#varChar. - def visitVarChar(self, ctx: TestFileParser.VarCharContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#fixedBinary. - def visitFixedBinary(self, ctx: TestFileParser.FixedBinaryContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#decimal. - def visitDecimal(self, ctx: TestFileParser.DecimalContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#precisionTimestamp. - def visitPrecisionTimestamp(self, ctx: TestFileParser.PrecisionTimestampContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#precisionTimestampTZ. - def visitPrecisionTimestampTZ( - self, ctx: TestFileParser.PrecisionTimestampTZContext - ): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#parameterizedType. - def visitParameterizedType(self, ctx: TestFileParser.ParameterizedTypeContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#integerLiteral. - def visitIntegerLiteral(self, ctx: TestFileParser.IntegerLiteralContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#substraitError. - def visitSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#func_option. - def visitFunc_option(self, ctx: TestFileParser.Func_optionContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#option_name. - def visitOption_name(self, ctx: TestFileParser.Option_nameContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#option_value. - def visitOption_value(self, ctx: TestFileParser.Option_valueContext): - return self.visitChildren(ctx) - - # Visit a parse tree produced by TestFileParser#func_options. - def visitFunc_options(self, ctx: TestFileParser.Func_optionsContext): - return self.visitChildren(ctx) - - -del TestFileParser diff --git a/tests/coverage/case_file_parser.py b/tests/coverage/case_file_parser.py index d49c9bacb..013c386c4 100644 --- a/tests/coverage/case_file_parser.py +++ b/tests/coverage/case_file_parser.py @@ -3,16 +3,16 @@ from antlr4 import CommonTokenStream, FileStream -from tests.coverage.antlr_parser.TestFileLexer import TestFileLexer -from tests.coverage.antlr_parser.TestFileParser import TestFileParser +from tests.coverage.antlr_parser.FuncTestCaseLexer import FuncTestCaseLexer +from tests.coverage.antlr_parser.FuncTestCaseParser import FuncTestCaseParser from tests.coverage.visitor import TestCaseVisitor def parse_stream(input_stream, file_path): # Create a lexer and parser - lexer = TestFileLexer(input_stream) + lexer = FuncTestCaseLexer(input_stream) token_stream = CommonTokenStream(lexer) - parser = TestFileParser(token_stream) + parser = FuncTestCaseParser(token_stream) tree = parser.doc() # This is the entry point of testfile parser if parser.getNumberOfSyntaxErrors() > 0: diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index 6d8f40379..12372565b 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -1,4 +1,5 @@ # SPDX-License-Identifier: Apache-2.0 +import json from collections import defaultdict from tests.coverage.case_file_parser import load_all_testcases @@ -19,6 +20,13 @@ def update_coverage(self, function_variant, count): self.function_variant_coverage[function_variant] += count self.test_count += count + def to_dict(self): + return { + "function_name": self.function_name, + "test_count": self.test_count, + "variants": [{"signature": variant, "test_count": count} for variant, count in self.function_variant_coverage.items()] + } + class FileTestCoverage: file_name: str @@ -37,14 +45,25 @@ def update_coverage(self, func_name, args, count): self.function_coverage[func_name].update_coverage(key, count) self.test_count += count + def to_dict(self): + return { + "file_name": self.file_name, + "test_count": self.test_count, + "function_coverage": [func_coverage.to_dict() for func_name, func_coverage in self.function_coverage.items()], + } + class TestCoverage: file_coverage: dict[str, FileTestCoverage] test_count: int + num_covered_variants: int + total_variants: int def __init__(self, ext_uris): self.file_coverage = dict() self.test_count = 0 + self.num_covered_variants = 0 + self.total_variants = 0 for ext_uri in ext_uris: self.file_coverage[ext_uri] = FileTestCoverage(ext_uri) @@ -54,22 +73,24 @@ def update_coverage(self, ext_uri, function, args, count): self.file_coverage[ext_uri].update_coverage(function, args, count) self.test_count += count - def dump_coverage(self): - covered_variants = 0 - total_variants = 0 + def compute_coverage(self): for file_coverage in self.file_coverage.values(): for function_coverage in file_coverage.function_coverage.values(): - for ( - sig, - test_count, - ) in function_coverage.function_variant_coverage.items(): - total_variants += 1 + for test_count in function_coverage.function_variant_coverage.values(): if test_count > 0: - covered_variants += 1 - print(f"{file_coverage.file_name} \t\t{sig}: {test_count}") - print( - f"Total test count: {self.test_count}, {covered_variants}/{total_variants} function variants are covered" - ) + self.num_covered_variants += 1 + self.total_variants += 1 + + def to_dict(self): + return { + "file_coverage": [file_coverage.to_dict() for file_coverage in self.file_coverage.values()], + "test_count": self.test_count, + "num_covered_function_variants": self.num_covered_variants, + "total_function_variants": self.total_variants, + } + + def to_json(self): + return json.dumps(self.to_dict(), indent=2) def update_test_count(test_case_files: list, function_registry: FunctionRegistry): @@ -98,4 +119,5 @@ def update_test_count(test_case_files: list, function_registry: FunctionRegistry coverage = TestCoverage(function_registry.get_extension_list()) update_test_count(test_files, function_registry) function_registry.fill_coverage(coverage) - coverage.dump_coverage() + coverage.compute_coverage() + print(coverage.to_json()) diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index ef1cbbec6..3aa53d312 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -1,8 +1,11 @@ # SPDX-License-Identifier: Apache-2.0 import os import yaml +from antlr4 import InputStream from ruamel.yaml import YAML +from tests.coverage.antlr_parser.SubstraitLexer import SubstraitLexer + enable_debug = False @@ -15,52 +18,48 @@ def debug(msg): print(f"DEBUG: {msg}") -type_to_short_type = { - "required enumeration": "req", - "i8": "i8", - "i16": "i16", - "i32": "i32", - "i64": "i64", - "fp32": "fp32", - "fp64": "fp64", - "string": "str", - "binary": "vbin", - "boolean": "bool", - "timestamp": "ts", - "timestamp_tz": "tstz", - "date": "date", - "time": "time", - "interval_year": "iyear", - "interval_day": "iday", - "uuid": "uuid", - "fixedchar": "fchar", - "varchar": "vchar", - "fixedbinary": "fbin", - "decimal": "dec", - "precision_timestamp

": "pts", - "precision_timestamp_tz

": "ptstz", - "struct": "struct", - "list": "list", - "map": "map", - "map": "map", - "any": "any", - "any1": "any1", - "any2": "any2", - "any3": "any3", - "user defined type": "u!name", - # added to handle parametrized types - "fixedchar": "fchar", - "varchar": "vchar", - "fixedbinary": "fbin", - "decimal": "dec", - "precision_timestamp": "pts", - "precision_timestamp_tz": "ptstz", - "struct": "struct", - "list": "list", - # added to handle geometry type - "geometry": "geometry", -} - +def substrait_type_str(rule_num): + return SubstraitLexer.symbolicNames[rule_num].lower() + + +def build_type_to_short_type(): + rule_map = { + SubstraitLexer.I8: SubstraitLexer.I8, + SubstraitLexer.I16: SubstraitLexer.I16, + SubstraitLexer.I32: SubstraitLexer.I32, + SubstraitLexer.I64: SubstraitLexer.I64, + SubstraitLexer.FP32: SubstraitLexer.FP32, + SubstraitLexer.FP64: SubstraitLexer.FP64, + SubstraitLexer.String: SubstraitLexer.Str, + SubstraitLexer.Binary: SubstraitLexer.VBin, + SubstraitLexer.Boolean: SubstraitLexer.Bool, + SubstraitLexer.Timestamp: SubstraitLexer.Ts, + SubstraitLexer.Timestamp_TZ: SubstraitLexer.TsTZ, + SubstraitLexer.Date: SubstraitLexer.Date, + SubstraitLexer.Time: SubstraitLexer.Time, + SubstraitLexer.Interval_Year: SubstraitLexer.IYear, + SubstraitLexer.Interval_Day: SubstraitLexer.IDay, + SubstraitLexer.UUID: SubstraitLexer.UUID, + SubstraitLexer.FixedChar: SubstraitLexer.FChar, + SubstraitLexer.VarChar: SubstraitLexer.VChar, + SubstraitLexer.FixedBinary: SubstraitLexer.FBin, + SubstraitLexer.Decimal: SubstraitLexer.Dec, + SubstraitLexer.Precision_Timestamp: SubstraitLexer.PTs, + SubstraitLexer.Precision_Timestamp_TZ: SubstraitLexer.PTsTZ, + SubstraitLexer.Struct: SubstraitLexer.Struct, + SubstraitLexer.List: SubstraitLexer.List, + SubstraitLexer.Map: SubstraitLexer.Map, + SubstraitLexer.ANY: SubstraitLexer.ANY, + SubstraitLexer.Geometry: SubstraitLexer.Geometry, + } + to_short_type = {substrait_type_str(k): substrait_type_str(v) for k, v in rule_map.items()} + any_type = substrait_type_str(SubstraitLexer.ANY) + for i in range(1, 3): + to_short_type[f"{any_type}{i}"] = f"{any_type}{i}" + return to_short_type + + +type_to_short_type = build_type_to_short_type() short_type_to_type = {st: lt for lt, st in type_to_short_type.items()} diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py index 8e0ce2fce..0508a72a6 100644 --- a/tests/coverage/test_coverage.py +++ b/tests/coverage/test_coverage.py @@ -5,56 +5,54 @@ def parse_string(input_string): - return parse_stream(InputStream(input_string)) + return parse_stream(InputStream(input_string), "test_string") -def test_parse_basic_example(): - test_file = parse_string( - """### SUBSTRAIT_SCALAR_TEST: v1.0 -### SUBSTRAIT_INCLUDE: '/extensions/functions_arithmetic.yaml' +def make_header(version, include): + return f"""### SUBSTRAIT_SCALAR_TEST: {version} +### SUBSTRAIT_INCLUDE: '{include}' + +""" + -# basic: 'Basic examples without any special cases' +def test_parse_basic_example(): + header = make_header("v1.0", "/extensions/functions_arithmetic.yaml") + tests = """# 'Basic examples without any special cases' add(120::i8, 5::i8) = 125::i8 add(100::i16, 100::i16) = 200::i16 -# overflow: Examples demonstrating overflow behavior +# Overflow examples demonstrating overflow behavior add(120::i8, 10::i8) [overflow:ERROR] = """ - ) + + test_str = header + tests + test_file = parse_string(header + tests) assert len(test_file.testcases) == 3 def test_parse_date_time_example(): - test_file = parse_string( - """### SUBSTRAIT_SCALAR_TEST: v1.0 - ### SUBSTRAIT_INCLUDE: '/extensions/functions_datetime.yaml' - -# timestamps: examples using the timestamp type + header = make_header("v1.0", "/extensions/functions_datetime.yaml") + tests = """# timestamp examples using the timestamp type lt('2016-12-31T13:30:15'::ts, '2017-12-31T13:30:15'::ts) = true::bool """ - ) + + test_file = parse_string(header + tests) assert len(test_file.testcases) == 1 assert test_file.testcases[0].func_name == "lt" assert test_file.testcases[0].base_uri == "/extensions/functions_datetime.yaml" - assert test_file.testcases[0].group.name == "timestamps" - assert ( - test_file.testcases[0].group.description == "examples using the timestamp type" - ) + assert test_file.testcases[0].group.name == "timestamp examples using the timestamp type" assert test_file.testcases[0].result == CaseLiteral("true", "bool") assert test_file.testcases[0].args[0] == CaseLiteral("2016-12-31T13:30:15", "ts") assert test_file.testcases[0].args[1] == CaseLiteral("2017-12-31T13:30:15", "ts") def test_parse_decimal_example(): - test_file = parse_string( - """### SUBSTRAIT_SCALAR_TEST: v1.0 -### SUBSTRAIT_INCLUDE: 'extensions/functions_arithmetic_decimal.yaml' - -# basic: Basic examples without any special cases + header = make_header("v1.0", "extensions/functions_arithmetic_decimal.yaml") + tests = """# basic power(8::dec<38,0>, 2::dec<38, 0>) = 64::fp64 power(1.0::dec<38, 0>, -1.0::dec<38, 0>) = 1.0::fp64 """ - ) + test_file = parse_string(header + tests) assert len(test_file.testcases) == 2 assert test_file.testcases[0].func_name == "power" assert ( @@ -62,10 +60,6 @@ def test_parse_decimal_example(): == "extensions/functions_arithmetic_decimal.yaml" ) assert test_file.testcases[0].group.name == "basic" - assert ( - test_file.testcases[0].group.description - == "Basic examples without any special cases" - ) assert test_file.testcases[0].result == CaseLiteral("64", "fp64") assert test_file.testcases[0].args[0] == CaseLiteral("8", "dec<38,0>") assert test_file.testcases[0].args[1] == CaseLiteral("2", "dec<38,0>") diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index 6087e9f6a..e6ae4720a 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -1,6 +1,6 @@ # SPDX-License-Identifier: Apache-2.0 -from tests.coverage.antlr_parser.TestFileParser import TestFileParser -from tests.coverage.antlr_parser.TestFileParserVisitor import TestFileParserVisitor +from tests.coverage.antlr_parser.FuncTestCaseParser import FuncTestCaseParser +from tests.coverage.antlr_parser.FuncTestCaseParserVisitor import FuncTestCaseParserVisitor from tests.coverage.nodes import ( CaseGroup, TestFile, @@ -10,11 +10,11 @@ ) -class TestCaseVisitor(TestFileParserVisitor): +class TestCaseVisitor(FuncTestCaseParserVisitor): def __init__(self, file_path): self.file_path = file_path - def visitDoc(self, ctx: TestFileParser.DocContext): + def visitDoc(self, ctx: FuncTestCaseParser.DocContext): version, include = self.visitHeader(ctx.header()) testcases = [] for group in ctx.testGroup(): @@ -25,29 +25,25 @@ def visitDoc(self, ctx: TestFileParser.DocContext): return TestFile(self.file_path, version, include, testcases) - def visitHeader(self, ctx: TestFileParser.HeaderContext): + def visitHeader(self, ctx: FuncTestCaseParser.HeaderContext): version = self.visitVersion(ctx.version()) include = self.visitInclude(ctx.include()) return version, include - def visitVersion(self, ctx: TestFileParser.VersionContext): + def visitVersion(self, ctx: FuncTestCaseParser.VersionContext): return ctx.FORMAT_VERSION().getText() - def visitInclude(self, ctx: TestFileParser.IncludeContext): + def visitInclude(self, ctx: FuncTestCaseParser.IncludeContext): # TODO handle multiple includes return ctx.STRING_LITERAL(0).getText().strip("'") def visitTestGroupDescription( - self, ctx: TestFileParser.TestGroupDescriptionContext + self, ctx: FuncTestCaseParser.TestGroupDescriptionContext ): group = ctx.DESCRIPTION_LINE().getText().strip("#").strip() - parts = group.split(":") - if len(parts) == 2: - return CaseGroup(parts[0].strip(), parts[1].strip()) - return CaseGroup(group, "") - def visitTestGroup(self, ctx: TestFileParser.TestGroupContext): + def visitTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): group = self.visitTestGroupDescription(ctx.testGroupDescription()) test_cases = [] for test_case in ctx.testCase(): @@ -56,7 +52,7 @@ def visitTestGroup(self, ctx: TestFileParser.TestGroupContext): test_cases.append(testcase) return group, test_cases - def visitTestCase(self, ctx: TestFileParser.TestCaseContext): + def visitTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): # TODO Implement this method args = self.visitArguments(ctx.arguments()) result = self.visitResult(ctx.result()) @@ -73,25 +69,25 @@ def visitTestCase(self, ctx: TestFileParser.TestCaseContext): comment="", ) - def visitFunc_options(self, ctx: TestFileParser.Func_optionsContext): + def visitFunc_options(self, ctx: FuncTestCaseParser.Func_optionsContext): options = {} for option in ctx.func_option(): key, value = self.visitFunc_option(option) options[key] = value return options - def visitFunc_option(self, ctx: TestFileParser.Func_optionContext): + def visitFunc_option(self, ctx: FuncTestCaseParser.Func_optionContext): key = ctx.option_name().getText() value = ctx.option_value().getText() return key, value - def visitArguments(self, ctx: TestFileParser.ArgumentsContext): + def visitArguments(self, ctx: FuncTestCaseParser.ArgumentsContext): arguments = [] for arg in ctx.argument(): arguments.append(self.visitArgument(arg)) return arguments - def visitArgument(self, ctx: TestFileParser.ArgumentContext): + def visitArgument(self, ctx: FuncTestCaseParser.ArgumentContext): if ctx.i8Arg() is not None: return self.visitI8Arg(ctx.i8Arg()) if ctx.i16Arg() is not None: @@ -127,86 +123,86 @@ def visitArgument(self, ctx: TestFileParser.ArgumentContext): return CaseLiteral(value="unknown_value", type="unknown_type") - def visitNumericLiteral(self, ctx: TestFileParser.NumericLiteralContext): + def visitNumericLiteral(self, ctx: FuncTestCaseParser.NumericLiteralContext): if ctx.INTEGER_LITERAL() is not None: return ctx.INTEGER_LITERAL().getText() if ctx.DECIMAL_LITERAL() is not None: return ctx.DECIMAL_LITERAL().getText() return ctx.FLOAT_LITERAL - def visitNullArg(self, ctx: TestFileParser.NullArgContext): + def visitNullArg(self, ctx: FuncTestCaseParser.NullArgContext): datatype = ctx.datatype().getText() return CaseLiteral(value=None, type=datatype) - def visitI8Arg(self, ctx: TestFileParser.I8ArgContext): + def visitI8Arg(self, ctx: FuncTestCaseParser.I8ArgContext): return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i8") - def visitI16Arg(self, ctx: TestFileParser.I16ArgContext): + def visitI16Arg(self, ctx: FuncTestCaseParser.I16ArgContext): return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i16") - def visitI32Arg(self, ctx: TestFileParser.I32ArgContext): + def visitI32Arg(self, ctx: FuncTestCaseParser.I32ArgContext): return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i32") - def visitI64Arg(self, ctx: TestFileParser.I64ArgContext): + def visitI64Arg(self, ctx: FuncTestCaseParser.I64ArgContext): return CaseLiteral(value=ctx.INTEGER_LITERAL().getText(), type="i64") - def visitFp32Arg(self, ctx: TestFileParser.Fp32ArgContext): + def visitFp32Arg(self, ctx: FuncTestCaseParser.Fp32ArgContext): # TODO add checks on number of decimal places return CaseLiteral( value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.FP32().getText().lower(), ) - def visitFp64Arg(self, ctx: TestFileParser.Fp64ArgContext): + def visitFp64Arg(self, ctx: FuncTestCaseParser.Fp64ArgContext): return CaseLiteral( value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.FP64().getText().lower(), ) - def visitBooleanArg(self, ctx: TestFileParser.BooleanArgContext): + def visitBooleanArg(self, ctx: FuncTestCaseParser.BooleanArgContext): return CaseLiteral(value=ctx.BOOLEAN_LITERAL().getText(), type="bool") - def visitStringArg(self, ctx: TestFileParser.StringArgContext): + def visitStringArg(self, ctx: FuncTestCaseParser.StringArgContext): return CaseLiteral(value=ctx.STRING_LITERAL().getText(), type="str") - def visitDecimalArg(self, ctx: TestFileParser.DecimalArgContext): + def visitDecimalArg(self, ctx: FuncTestCaseParser.DecimalArgContext): return CaseLiteral( value=self.visitNumericLiteral(ctx.numericLiteral()), type=ctx.decimalType().getText().lower(), ) - def visitDateArg(self, ctx: TestFileParser.DateArgContext): + def visitDateArg(self, ctx: FuncTestCaseParser.DateArgContext): return CaseLiteral(value=ctx.DATE_LITERAL().getText().strip("'"), type="date") - def visitTimeArg(self, ctx: TestFileParser.TimeArgContext): + def visitTimeArg(self, ctx: FuncTestCaseParser.TimeArgContext): return CaseLiteral(value=ctx.TIME_LITERAL().getText().strip("'"), type="time") - def visitTimestampArg(self, ctx: TestFileParser.TimestampArgContext): + def visitTimestampArg(self, ctx: FuncTestCaseParser.TimestampArgContext): return CaseLiteral( value=ctx.TIMESTAMP_LITERAL().getText().strip("'"), type="ts" ) - def visitTimestampTzArg(self, ctx: TestFileParser.TimestampTzArgContext): + def visitTimestampTzArg(self, ctx: FuncTestCaseParser.TimestampTzArgContext): return CaseLiteral( value=ctx.TIMESTAMP_TZ_LITERAL().getText().strip("'"), type="tstz" ) - def visitIntervalDayArg(self, ctx: TestFileParser.IntervalDayArgContext): + def visitIntervalDayArg(self, ctx: FuncTestCaseParser.IntervalDayArgContext): return CaseLiteral( value=ctx.INTERVAL_DAY_LITERAL().getText().strip("'"), type="iday" ) - def visitIntervalYearArg(self, ctx: TestFileParser.IntervalYearArgContext): + def visitIntervalYearArg(self, ctx: FuncTestCaseParser.IntervalYearArgContext): return CaseLiteral( value=ctx.INTERVAL_YEAR_LITERAL().getText().strip("'"), type="iyear" ) - def visitResult(self, ctx: TestFileParser.ResultContext): + def visitResult(self, ctx: FuncTestCaseParser.ResultContext): if ctx.argument() is not None: return self.visitArgument(ctx.argument()) return self.visitSubstraitError(ctx.substraitError()) - def visitSubstraitError(self, ctx: TestFileParser.SubstraitErrorContext): + def visitSubstraitError(self, ctx: FuncTestCaseParser.SubstraitErrorContext): if ctx.ERROR_RESULT() is not None: return SubstraitError("error") if ctx.UNDEFINED_RESULT() is not None: diff --git a/tests/test_extensions.py b/tests/test_extensions.py index 0facf7395..3de4855c6 100644 --- a/tests/test_extensions.py +++ b/tests/test_extensions.py @@ -1,12 +1,38 @@ # SPDX-License-Identifier: Apache-2.0 +from tests.coverage.extensions import build_type_to_short_type + + def test_read_substrait_extensions(): from tests.coverage.extensions import Extension registry = Extension.read_substrait_extensions("../extensions") - assert len(registry.function_registry) >= 143 - num_overloads = sum([len(f) for f in registry.function_registry.values()]) - assert num_overloads >= 425 + assert len(registry.registry) >= 161 + num_overloads = sum([len(f) for f in registry.registry.values()]) + assert num_overloads >= 510 assert len(registry.dependencies) >= 13 assert len(registry.scalar_functions) >= 162 assert len(registry.aggregate_functions) >= 29 assert len(registry.window_functions) >= 0 + + +def test_build_type_to_short_type(): + long_to_short = build_type_to_short_type() + assert long_to_short["i64"] == "i64" + assert long_to_short["fp64"] == "fp64" + assert long_to_short["timestamp"] == "ts" + assert long_to_short["timestamp_tz"] == "tstz" + assert long_to_short["precision_timestamp"] == "pts" + assert long_to_short["precision_timestamp_tz"] == "ptstz" + assert long_to_short["interval_year"] == "iyear" + assert long_to_short["interval_day"] == "iday" + assert long_to_short["decimal"] == "dec" + assert long_to_short["boolean"] == "bool" + assert long_to_short["string"] == "str" + assert long_to_short["binary"] == "vbin" + assert long_to_short["fixedbinary"] == "fbin" + assert long_to_short["fixedchar"] == "fchar" + assert long_to_short["varchar"] == "vchar" + assert long_to_short["list"] == "list" + assert long_to_short["map"] == "map" + assert long_to_short["struct"] == "struct" + From 39ff79285d203ff9760d49228f228829e13a6bba Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Thu, 12 Sep 2024 20:03:57 +0530 Subject: [PATCH 15/19] code style --- .../antlr_parser/FuncTestCaseLexer.py | 10500 +++++++++++++++- .../antlr_parser/FuncTestCaseParser.py | 5854 +++++++-- .../FuncTestCaseParserListener.py | 325 +- .../antlr_parser/FuncTestCaseParserVisitor.py | 197 +- tests/coverage/antlr_parser/SubstraitLexer.py | 5777 ++++++++- tests/coverage/coverage.py | 14 +- tests/coverage/extensions.py | 12 +- tests/coverage/test_coverage.py | 5 +- tests/coverage/visitor.py | 4 +- tests/test_extensions.py | 1 - 10 files changed, 20413 insertions(+), 2276 deletions(-) diff --git a/tests/coverage/antlr_parser/FuncTestCaseLexer.py b/tests/coverage/antlr_parser/FuncTestCaseLexer.py index e68b3cae4..2cee7d59a 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseLexer.py +++ b/tests/coverage/antlr_parser/FuncTestCaseLexer.py @@ -2,6 +2,7 @@ from antlr4 import * from io import StringIO import sys + if sys.version_info[1] > 5: from typing import TextIO else: @@ -10,428 +11,9770 @@ def serializedATN(): return [ - 4,0,95,1129,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, - 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, - 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, - 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, - 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, - 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, - 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, - 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, - 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, - 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, - 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, - 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, - 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, - 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2, - 91,7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7, - 97,2,98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103, - 7,103,2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108, - 2,109,7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114, - 7,114,2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119, - 2,120,7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125, - 7,125,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1, - 0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,1,1,1,4,1,283, - 8,1,11,1,12,1,284,1,1,1,1,4,1,289,8,1,11,1,12,1,290,3,1,293,8,1, - 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2, - 1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,3,1,3,1,3,1,3,5,3,322,8,3,10,3,12, - 3,325,9,3,1,3,3,3,328,8,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1, - 4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,6,1, - 6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1,7,1, - 7,1,8,1,8,1,8,1,8,1,8,1,8,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1, - 10,1,10,1,10,1,10,1,10,1,10,1,10,1,11,1,11,1,11,1,11,1,11,1,11,1, - 11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13,3,13,411,8, - 13,1,13,1,13,1,14,3,14,416,8,14,1,14,4,14,419,8,14,11,14,12,14,420, - 1,14,1,14,4,14,425,8,14,11,14,12,14,426,3,14,429,8,14,1,15,3,15, - 432,8,15,1,15,4,15,435,8,15,11,15,12,15,436,1,15,1,15,5,15,441,8, - 15,10,15,12,15,444,9,15,3,15,446,8,15,1,15,1,15,3,15,450,8,15,1, - 15,4,15,453,8,15,11,15,12,15,454,3,15,457,8,15,1,15,3,15,460,8,15, - 1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15, - 3,15,475,8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,3,16, - 486,8,16,1,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19, - 1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,4,19,510, - 8,19,11,19,12,19,511,3,19,514,8,19,1,19,1,19,1,19,1,19,1,19,1,19, - 1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20, - 1,20,4,20,536,8,20,11,20,12,20,537,3,20,540,8,20,1,20,1,20,1,21, - 1,21,1,21,1,21,1,21,1,21,1,21,1,21,4,21,552,8,21,11,21,12,21,553, - 3,21,556,8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22, - 1,23,1,23,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29, - 1,29,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,591,8,31, - 1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,3,31,601,8,31,1,32,1,32, - 1,32,1,32,1,32,1,32,1,32,3,32,610,8,32,1,32,1,32,1,32,1,32,1,32, - 1,32,1,32,1,32,3,32,620,8,32,1,33,1,33,1,33,1,33,1,33,3,33,627,8, - 33,1,33,1,33,1,33,3,33,632,8,33,1,33,1,33,1,33,3,33,637,8,33,1,33, - 1,33,1,33,1,33,1,33,3,33,644,8,33,1,33,1,33,1,33,3,33,649,8,33,1, - 33,1,33,1,33,1,33,1,33,3,33,656,8,33,1,33,1,33,1,33,3,33,661,8,33, - 1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,5,35,674, - 8,35,10,35,12,35,677,9,35,1,35,1,35,1,36,1,36,1,36,1,36,5,36,685, - 8,36,10,36,12,36,688,9,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,4,37, - 697,8,37,11,37,12,37,698,1,37,3,37,702,8,37,1,37,5,37,705,8,37,10, - 37,12,37,708,9,37,1,37,1,37,1,37,1,37,1,37,1,38,4,38,716,8,38,11, - 38,12,38,717,1,38,1,38,1,39,1,39,1,40,1,40,1,41,1,41,1,42,1,42,1, - 43,1,43,1,44,1,44,1,45,1,45,1,46,1,46,1,47,1,47,1,48,1,48,1,49,1, - 49,1,50,1,50,1,51,1,51,1,52,1,52,1,53,1,53,1,54,1,54,1,55,1,55,1, - 56,1,56,1,57,1,57,1,58,1,58,1,59,1,59,1,60,1,60,1,61,1,61,1,62,1, - 62,1,63,1,63,1,64,1,64,1,65,1,65,1,66,1,66,1,66,5,66,779,8,66,10, - 66,12,66,782,9,66,3,66,784,8,66,1,67,1,67,1,67,1,68,1,68,1,68,1, - 68,1,68,1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1, - 70,1,70,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1, - 74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1, - 76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,1,78,1,78,1,78,1,78,1,78,1, - 78,1,78,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1, - 80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,80,1,81,1, - 81,1,81,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,83,1,83,1,83,1,83,1, - 83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,84,1, - 84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,85,1,85,1,85,1, - 85,1,85,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1, - 87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1,87,1, - 87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1, - 88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1, - 88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,90,1,90,1, - 90,1,90,1,90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,91,1,91,1, - 91,1,91,1,91,1,91,1,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,1,93,1, - 93,1,93,1,93,1,93,1,93,1,93,1,93,1,94,1,94,1,94,1,94,1,94,1,95,1, - 95,1,95,1,95,1,96,1,96,1,96,1,96,1,97,1,97,1,97,1,98,1,98,1,98,1, - 98,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,99,1,100,1,100, - 1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,102,1,102,1,102,1,103, - 1,103,1,103,1,103,1,103,1,104,1,104,1,104,1,104,1,104,1,104,1,105, - 1,105,1,105,1,105,1,105,1,106,1,106,1,106,1,106,1,107,1,107,1,107, - 1,107,1,108,1,108,1,108,1,108,1,108,1,108,1,109,1,109,1,109,1,109, - 1,109,1,109,1,110,1,110,1,110,1,110,1,110,1,110,1,111,1,111,1,111, - 1,111,1,111,1,112,1,112,1,112,1,113,1,113,5,113,1101,8,113,10,113, - 12,113,1104,9,113,1,114,1,114,1,115,1,115,1,116,1,116,1,117,1,117, - 1,118,1,118,1,119,1,119,1,120,1,120,1,121,1,121,1,122,1,122,1,123, - 1,123,1,124,1,124,1,125,1,125,0,0,126,1,1,3,2,5,3,7,4,9,5,11,6,13, - 7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29,15,31,16,33,17,35,0, - 37,0,39,18,41,19,43,20,45,21,47,22,49,23,51,24,53,25,55,26,57,27, - 59,28,61,29,63,30,65,31,67,0,69,32,71,33,73,34,75,35,77,36,79,0, - 81,0,83,0,85,0,87,0,89,0,91,0,93,0,95,0,97,0,99,0,101,0,103,0,105, - 0,107,0,109,0,111,0,113,0,115,0,117,0,119,0,121,0,123,0,125,0,127, - 0,129,0,131,0,133,0,135,37,137,38,139,39,141,40,143,41,145,42,147, - 43,149,44,151,45,153,46,155,47,157,48,159,49,161,50,163,51,165,52, - 167,53,169,54,171,55,173,56,175,57,177,58,179,59,181,60,183,61,185, - 62,187,63,189,64,191,65,193,66,195,67,197,68,199,69,201,70,203,71, - 205,72,207,73,209,74,211,75,213,76,215,77,217,78,219,79,221,80,223, - 81,225,82,227,83,229,84,231,85,233,86,235,87,237,88,239,89,241,90, - 243,91,245,92,247,93,249,94,251,95,1,0,36,2,0,10,10,13,13,2,0,43, - 43,45,45,1,0,48,57,2,0,69,69,101,101,2,0,39,39,92,92,1,0,42,42,2, - 0,42,42,47,47,3,0,9,10,13,13,32,32,2,0,65,65,97,97,2,0,66,66,98, - 98,2,0,67,67,99,99,2,0,68,68,100,100,2,0,70,70,102,102,2,0,71,71, - 103,103,2,0,72,72,104,104,2,0,73,73,105,105,2,0,74,74,106,106,2, - 0,75,75,107,107,2,0,76,76,108,108,2,0,77,77,109,109,2,0,78,78,110, - 110,2,0,79,79,111,111,2,0,80,80,112,112,2,0,81,81,113,113,2,0,82, - 82,114,114,2,0,83,83,115,115,2,0,84,84,116,116,2,0,85,85,117,117, - 2,0,86,86,118,118,2,0,87,87,119,119,2,0,88,88,120,120,2,0,89,89, - 121,121,2,0,90,90,122,122,1,0,49,57,3,0,65,90,95,95,97,122,4,0,48, - 57,65,90,95,95,97,122,1150,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0, - 7,1,0,0,0,0,9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17, - 1,0,0,0,0,19,1,0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27, - 1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0,0,33,1,0,0,0,0,39,1,0,0,0,0,41, - 1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51, - 1,0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61, - 1,0,0,0,0,63,1,0,0,0,0,65,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73, - 1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0, - 139,1,0,0,0,0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0, - 0,0,0,149,1,0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157, - 1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0, - 0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1, - 0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,0,0,0,0,183,1,0,0,0,0, - 185,1,0,0,0,0,187,1,0,0,0,0,189,1,0,0,0,0,191,1,0,0,0,0,193,1,0, - 0,0,0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0,0,0,0,201,1,0,0,0,0,203, - 1,0,0,0,0,205,1,0,0,0,0,207,1,0,0,0,0,209,1,0,0,0,0,211,1,0,0,0, - 0,213,1,0,0,0,0,215,1,0,0,0,0,217,1,0,0,0,0,219,1,0,0,0,0,221,1, - 0,0,0,0,223,1,0,0,0,0,225,1,0,0,0,0,227,1,0,0,0,0,229,1,0,0,0,0, - 231,1,0,0,0,0,233,1,0,0,0,0,235,1,0,0,0,0,237,1,0,0,0,0,239,1,0, - 0,0,0,241,1,0,0,0,0,243,1,0,0,0,0,245,1,0,0,0,0,247,1,0,0,0,0,249, - 1,0,0,0,0,251,1,0,0,0,1,253,1,0,0,0,3,280,1,0,0,0,5,294,1,0,0,0, - 7,317,1,0,0,0,9,331,1,0,0,0,11,340,1,0,0,0,13,353,1,0,0,0,15,362, - 1,0,0,0,17,371,1,0,0,0,19,377,1,0,0,0,21,386,1,0,0,0,23,393,1,0, - 0,0,25,405,1,0,0,0,27,410,1,0,0,0,29,415,1,0,0,0,31,474,1,0,0,0, - 33,485,1,0,0,0,35,487,1,0,0,0,37,492,1,0,0,0,39,495,1,0,0,0,41,521, - 1,0,0,0,43,543,1,0,0,0,45,559,1,0,0,0,47,567,1,0,0,0,49,569,1,0, - 0,0,51,571,1,0,0,0,53,573,1,0,0,0,55,575,1,0,0,0,57,577,1,0,0,0, - 59,579,1,0,0,0,61,581,1,0,0,0,63,600,1,0,0,0,65,619,1,0,0,0,67,660, - 1,0,0,0,69,662,1,0,0,0,71,667,1,0,0,0,73,680,1,0,0,0,75,691,1,0, - 0,0,77,715,1,0,0,0,79,721,1,0,0,0,81,723,1,0,0,0,83,725,1,0,0,0, - 85,727,1,0,0,0,87,729,1,0,0,0,89,731,1,0,0,0,91,733,1,0,0,0,93,735, - 1,0,0,0,95,737,1,0,0,0,97,739,1,0,0,0,99,741,1,0,0,0,101,743,1,0, - 0,0,103,745,1,0,0,0,105,747,1,0,0,0,107,749,1,0,0,0,109,751,1,0, - 0,0,111,753,1,0,0,0,113,755,1,0,0,0,115,757,1,0,0,0,117,759,1,0, - 0,0,119,761,1,0,0,0,121,763,1,0,0,0,123,765,1,0,0,0,125,767,1,0, - 0,0,127,769,1,0,0,0,129,771,1,0,0,0,131,773,1,0,0,0,133,783,1,0, - 0,0,135,785,1,0,0,0,137,788,1,0,0,0,139,793,1,0,0,0,141,798,1,0, - 0,0,143,806,1,0,0,0,145,809,1,0,0,0,147,813,1,0,0,0,149,817,1,0, - 0,0,151,821,1,0,0,0,153,826,1,0,0,0,155,831,1,0,0,0,157,838,1,0, - 0,0,159,845,1,0,0,0,161,855,1,0,0,0,163,868,1,0,0,0,165,873,1,0, - 0,0,167,878,1,0,0,0,169,892,1,0,0,0,171,905,1,0,0,0,173,910,1,0, - 0,0,175,918,1,0,0,0,177,938,1,0,0,0,179,961,1,0,0,0,181,971,1,0, - 0,0,183,979,1,0,0,0,185,991,1,0,0,0,187,998,1,0,0,0,189,1006,1,0, - 0,0,191,1011,1,0,0,0,193,1015,1,0,0,0,195,1019,1,0,0,0,197,1022, - 1,0,0,0,199,1031,1,0,0,0,201,1036,1,0,0,0,203,1040,1,0,0,0,205,1045, - 1,0,0,0,207,1048,1,0,0,0,209,1053,1,0,0,0,211,1059,1,0,0,0,213,1064, - 1,0,0,0,215,1068,1,0,0,0,217,1072,1,0,0,0,219,1078,1,0,0,0,221,1084, - 1,0,0,0,223,1090,1,0,0,0,225,1095,1,0,0,0,227,1098,1,0,0,0,229,1105, - 1,0,0,0,231,1107,1,0,0,0,233,1109,1,0,0,0,235,1111,1,0,0,0,237,1113, - 1,0,0,0,239,1115,1,0,0,0,241,1117,1,0,0,0,243,1119,1,0,0,0,245,1121, - 1,0,0,0,247,1123,1,0,0,0,249,1125,1,0,0,0,251,1127,1,0,0,0,253,254, - 5,35,0,0,254,255,5,35,0,0,255,256,5,35,0,0,256,257,5,32,0,0,257, - 258,5,83,0,0,258,259,5,85,0,0,259,260,5,66,0,0,260,261,5,83,0,0, - 261,262,5,84,0,0,262,263,5,82,0,0,263,264,5,65,0,0,264,265,5,73, - 0,0,265,266,5,84,0,0,266,267,5,95,0,0,267,268,5,83,0,0,268,269,5, - 67,0,0,269,270,5,65,0,0,270,271,5,76,0,0,271,272,5,65,0,0,272,273, - 5,82,0,0,273,274,5,95,0,0,274,275,5,84,0,0,275,276,5,69,0,0,276, - 277,5,83,0,0,277,278,5,84,0,0,278,279,5,58,0,0,279,2,1,0,0,0,280, - 282,5,118,0,0,281,283,3,131,65,0,282,281,1,0,0,0,283,284,1,0,0,0, - 284,282,1,0,0,0,284,285,1,0,0,0,285,292,1,0,0,0,286,288,5,46,0,0, - 287,289,3,131,65,0,288,287,1,0,0,0,289,290,1,0,0,0,290,288,1,0,0, - 0,290,291,1,0,0,0,291,293,1,0,0,0,292,286,1,0,0,0,292,293,1,0,0, - 0,293,4,1,0,0,0,294,295,5,35,0,0,295,296,5,35,0,0,296,297,5,35,0, - 0,297,298,5,32,0,0,298,299,5,83,0,0,299,300,5,85,0,0,300,301,5,66, - 0,0,301,302,5,83,0,0,302,303,5,84,0,0,303,304,5,82,0,0,304,305,5, - 65,0,0,305,306,5,73,0,0,306,307,5,84,0,0,307,308,5,95,0,0,308,309, - 5,73,0,0,309,310,5,78,0,0,310,311,5,67,0,0,311,312,5,76,0,0,312, - 313,5,85,0,0,313,314,5,68,0,0,314,315,5,69,0,0,315,316,5,58,0,0, - 316,6,1,0,0,0,317,318,5,35,0,0,318,319,5,32,0,0,319,323,1,0,0,0, - 320,322,8,0,0,0,321,320,1,0,0,0,322,325,1,0,0,0,323,321,1,0,0,0, - 323,324,1,0,0,0,324,327,1,0,0,0,325,323,1,0,0,0,326,328,5,13,0,0, - 327,326,1,0,0,0,327,328,1,0,0,0,328,329,1,0,0,0,329,330,5,10,0,0, - 330,8,1,0,0,0,331,332,5,60,0,0,332,333,5,33,0,0,333,334,5,69,0,0, - 334,335,5,82,0,0,335,336,5,82,0,0,336,337,5,79,0,0,337,338,5,82, - 0,0,338,339,5,62,0,0,339,10,1,0,0,0,340,341,5,60,0,0,341,342,5,33, - 0,0,342,343,5,85,0,0,343,344,5,78,0,0,344,345,5,68,0,0,345,346,5, - 69,0,0,346,347,5,70,0,0,347,348,5,73,0,0,348,349,5,78,0,0,349,350, - 5,69,0,0,350,351,5,68,0,0,351,352,5,62,0,0,352,12,1,0,0,0,353,354, - 5,111,0,0,354,355,5,118,0,0,355,356,5,101,0,0,356,357,5,114,0,0, - 357,358,5,108,0,0,358,359,5,102,0,0,359,360,5,111,0,0,360,361,5, - 119,0,0,361,14,1,0,0,0,362,363,5,114,0,0,363,364,5,111,0,0,364,365, - 5,117,0,0,365,366,5,110,0,0,366,367,5,100,0,0,367,368,5,105,0,0, - 368,369,5,110,0,0,369,370,5,103,0,0,370,16,1,0,0,0,371,372,5,69, - 0,0,372,373,5,82,0,0,373,374,5,82,0,0,374,375,5,79,0,0,375,376,5, - 82,0,0,376,18,1,0,0,0,377,378,5,83,0,0,378,379,5,65,0,0,379,380, - 5,84,0,0,380,381,5,85,0,0,381,382,5,82,0,0,382,383,5,65,0,0,383, - 384,5,84,0,0,384,385,5,69,0,0,385,20,1,0,0,0,386,387,5,83,0,0,387, - 388,5,73,0,0,388,389,5,76,0,0,389,390,5,69,0,0,390,391,5,78,0,0, - 391,392,5,84,0,0,392,22,1,0,0,0,393,394,5,84,0,0,394,395,5,73,0, - 0,395,396,5,69,0,0,396,397,5,95,0,0,397,398,5,84,0,0,398,399,5,79, - 0,0,399,400,5,95,0,0,400,401,5,69,0,0,401,402,5,86,0,0,402,403,5, - 69,0,0,403,404,5,78,0,0,404,24,1,0,0,0,405,406,5,78,0,0,406,407, - 5,65,0,0,407,408,5,78,0,0,408,26,1,0,0,0,409,411,7,1,0,0,410,409, - 1,0,0,0,410,411,1,0,0,0,411,412,1,0,0,0,412,413,3,133,66,0,413,28, - 1,0,0,0,414,416,7,1,0,0,415,414,1,0,0,0,415,416,1,0,0,0,416,418, - 1,0,0,0,417,419,7,2,0,0,418,417,1,0,0,0,419,420,1,0,0,0,420,418, - 1,0,0,0,420,421,1,0,0,0,421,428,1,0,0,0,422,424,5,46,0,0,423,425, - 7,2,0,0,424,423,1,0,0,0,425,426,1,0,0,0,426,424,1,0,0,0,426,427, - 1,0,0,0,427,429,1,0,0,0,428,422,1,0,0,0,428,429,1,0,0,0,429,30,1, - 0,0,0,430,432,7,1,0,0,431,430,1,0,0,0,431,432,1,0,0,0,432,434,1, - 0,0,0,433,435,7,2,0,0,434,433,1,0,0,0,435,436,1,0,0,0,436,434,1, - 0,0,0,436,437,1,0,0,0,437,445,1,0,0,0,438,442,5,46,0,0,439,441,7, - 2,0,0,440,439,1,0,0,0,441,444,1,0,0,0,442,440,1,0,0,0,442,443,1, - 0,0,0,443,446,1,0,0,0,444,442,1,0,0,0,445,438,1,0,0,0,445,446,1, - 0,0,0,446,456,1,0,0,0,447,449,7,3,0,0,448,450,7,1,0,0,449,448,1, - 0,0,0,449,450,1,0,0,0,450,452,1,0,0,0,451,453,7,2,0,0,452,451,1, - 0,0,0,453,454,1,0,0,0,454,452,1,0,0,0,454,455,1,0,0,0,455,457,1, - 0,0,0,456,447,1,0,0,0,456,457,1,0,0,0,457,475,1,0,0,0,458,460,7, - 1,0,0,459,458,1,0,0,0,459,460,1,0,0,0,460,461,1,0,0,0,461,462,5, - 105,0,0,462,463,5,110,0,0,463,475,5,102,0,0,464,465,5,110,0,0,465, - 466,5,97,0,0,466,475,5,110,0,0,467,468,5,78,0,0,468,469,5,97,0,0, - 469,475,5,78,0,0,470,471,5,115,0,0,471,472,5,110,0,0,472,473,5,97, - 0,0,473,475,5,110,0,0,474,431,1,0,0,0,474,459,1,0,0,0,474,464,1, - 0,0,0,474,467,1,0,0,0,474,470,1,0,0,0,475,32,1,0,0,0,476,477,5,116, - 0,0,477,478,5,114,0,0,478,479,5,117,0,0,479,486,5,101,0,0,480,481, - 5,102,0,0,481,482,5,97,0,0,482,483,5,108,0,0,483,484,5,115,0,0,484, - 486,5,101,0,0,485,476,1,0,0,0,485,480,1,0,0,0,486,34,1,0,0,0,487, - 488,7,2,0,0,488,489,7,2,0,0,489,490,7,2,0,0,490,491,7,2,0,0,491, - 36,1,0,0,0,492,493,7,2,0,0,493,494,7,2,0,0,494,38,1,0,0,0,495,496, - 5,39,0,0,496,497,3,35,17,0,497,498,5,45,0,0,498,499,3,37,18,0,499, - 500,5,45,0,0,500,501,3,37,18,0,501,502,5,84,0,0,502,503,3,37,18, - 0,503,504,5,58,0,0,504,505,3,37,18,0,505,506,5,58,0,0,506,513,3, - 37,18,0,507,509,5,46,0,0,508,510,7,2,0,0,509,508,1,0,0,0,510,511, - 1,0,0,0,511,509,1,0,0,0,511,512,1,0,0,0,512,514,1,0,0,0,513,507, - 1,0,0,0,513,514,1,0,0,0,514,515,1,0,0,0,515,516,7,1,0,0,516,517, - 3,37,18,0,517,518,5,58,0,0,518,519,3,37,18,0,519,520,5,39,0,0,520, - 40,1,0,0,0,521,522,5,39,0,0,522,523,3,35,17,0,523,524,5,45,0,0,524, - 525,3,37,18,0,525,526,5,45,0,0,526,527,3,37,18,0,527,528,5,84,0, - 0,528,529,3,37,18,0,529,530,5,58,0,0,530,531,3,37,18,0,531,532,5, - 58,0,0,532,539,3,37,18,0,533,535,5,46,0,0,534,536,7,2,0,0,535,534, - 1,0,0,0,536,537,1,0,0,0,537,535,1,0,0,0,537,538,1,0,0,0,538,540, - 1,0,0,0,539,533,1,0,0,0,539,540,1,0,0,0,540,541,1,0,0,0,541,542, - 5,39,0,0,542,42,1,0,0,0,543,544,5,39,0,0,544,545,3,37,18,0,545,546, - 5,58,0,0,546,547,3,37,18,0,547,548,5,58,0,0,548,555,3,37,18,0,549, - 551,5,46,0,0,550,552,7,2,0,0,551,550,1,0,0,0,552,553,1,0,0,0,553, - 551,1,0,0,0,553,554,1,0,0,0,554,556,1,0,0,0,555,549,1,0,0,0,555, - 556,1,0,0,0,556,557,1,0,0,0,557,558,5,39,0,0,558,44,1,0,0,0,559, - 560,5,39,0,0,560,561,3,35,17,0,561,562,5,45,0,0,562,563,3,37,18, - 0,563,564,5,45,0,0,564,565,3,37,18,0,565,566,5,39,0,0,566,46,1,0, - 0,0,567,568,5,80,0,0,568,48,1,0,0,0,569,570,5,84,0,0,570,50,1,0, - 0,0,571,572,5,89,0,0,572,52,1,0,0,0,573,574,5,77,0,0,574,54,1,0, - 0,0,575,576,5,68,0,0,576,56,1,0,0,0,577,578,5,72,0,0,578,58,1,0, - 0,0,579,580,5,83,0,0,580,60,1,0,0,0,581,582,5,70,0,0,582,62,1,0, - 0,0,583,584,5,39,0,0,584,585,3,47,23,0,585,586,3,27,13,0,586,590, - 3,51,25,0,587,588,3,27,13,0,588,589,3,53,26,0,589,591,1,0,0,0,590, - 587,1,0,0,0,590,591,1,0,0,0,591,592,1,0,0,0,592,593,5,39,0,0,593, - 601,1,0,0,0,594,595,5,39,0,0,595,596,3,47,23,0,596,597,3,27,13,0, - 597,598,3,53,26,0,598,599,5,39,0,0,599,601,1,0,0,0,600,583,1,0,0, - 0,600,594,1,0,0,0,601,64,1,0,0,0,602,603,5,39,0,0,603,604,3,47,23, - 0,604,605,3,27,13,0,605,609,3,55,27,0,606,607,3,49,24,0,607,608, - 3,67,33,0,608,610,1,0,0,0,609,606,1,0,0,0,609,610,1,0,0,0,610,611, - 1,0,0,0,611,612,5,39,0,0,612,620,1,0,0,0,613,614,5,39,0,0,614,615, - 3,47,23,0,615,616,3,49,24,0,616,617,3,67,33,0,617,618,5,39,0,0,618, - 620,1,0,0,0,619,602,1,0,0,0,619,613,1,0,0,0,620,66,1,0,0,0,621,622, - 3,27,13,0,622,626,3,57,28,0,623,624,3,27,13,0,624,625,3,53,26,0, - 625,627,1,0,0,0,626,623,1,0,0,0,626,627,1,0,0,0,627,631,1,0,0,0, - 628,629,3,27,13,0,629,630,3,59,29,0,630,632,1,0,0,0,631,628,1,0, - 0,0,631,632,1,0,0,0,632,636,1,0,0,0,633,634,3,27,13,0,634,635,3, - 61,30,0,635,637,1,0,0,0,636,633,1,0,0,0,636,637,1,0,0,0,637,661, - 1,0,0,0,638,639,3,27,13,0,639,643,3,53,26,0,640,641,3,27,13,0,641, - 642,3,59,29,0,642,644,1,0,0,0,643,640,1,0,0,0,643,644,1,0,0,0,644, - 648,1,0,0,0,645,646,3,27,13,0,646,647,3,61,30,0,647,649,1,0,0,0, - 648,645,1,0,0,0,648,649,1,0,0,0,649,661,1,0,0,0,650,651,3,27,13, - 0,651,655,3,59,29,0,652,653,3,27,13,0,653,654,3,61,30,0,654,656, - 1,0,0,0,655,652,1,0,0,0,655,656,1,0,0,0,656,661,1,0,0,0,657,658, - 3,27,13,0,658,659,3,61,30,0,659,661,1,0,0,0,660,621,1,0,0,0,660, - 638,1,0,0,0,660,650,1,0,0,0,660,657,1,0,0,0,661,68,1,0,0,0,662,663, - 5,110,0,0,663,664,5,117,0,0,664,665,5,108,0,0,665,666,5,108,0,0, - 666,70,1,0,0,0,667,675,5,39,0,0,668,669,5,92,0,0,669,674,9,0,0,0, - 670,671,5,39,0,0,671,674,5,39,0,0,672,674,8,4,0,0,673,668,1,0,0, - 0,673,670,1,0,0,0,673,672,1,0,0,0,674,677,1,0,0,0,675,673,1,0,0, - 0,675,676,1,0,0,0,676,678,1,0,0,0,677,675,1,0,0,0,678,679,5,39,0, - 0,679,72,1,0,0,0,680,681,5,47,0,0,681,682,5,47,0,0,682,686,1,0,0, - 0,683,685,8,0,0,0,684,683,1,0,0,0,685,688,1,0,0,0,686,684,1,0,0, - 0,686,687,1,0,0,0,687,689,1,0,0,0,688,686,1,0,0,0,689,690,6,36,0, - 0,690,74,1,0,0,0,691,692,5,47,0,0,692,693,5,42,0,0,693,701,1,0,0, - 0,694,702,8,5,0,0,695,697,5,42,0,0,696,695,1,0,0,0,697,698,1,0,0, - 0,698,696,1,0,0,0,698,699,1,0,0,0,699,700,1,0,0,0,700,702,8,6,0, - 0,701,694,1,0,0,0,701,696,1,0,0,0,702,706,1,0,0,0,703,705,5,42,0, - 0,704,703,1,0,0,0,705,708,1,0,0,0,706,704,1,0,0,0,706,707,1,0,0, - 0,707,709,1,0,0,0,708,706,1,0,0,0,709,710,5,42,0,0,710,711,5,47, - 0,0,711,712,1,0,0,0,712,713,6,37,0,0,713,76,1,0,0,0,714,716,7,7, - 0,0,715,714,1,0,0,0,716,717,1,0,0,0,717,715,1,0,0,0,717,718,1,0, - 0,0,718,719,1,0,0,0,719,720,6,38,0,0,720,78,1,0,0,0,721,722,7,8, - 0,0,722,80,1,0,0,0,723,724,7,9,0,0,724,82,1,0,0,0,725,726,7,10,0, - 0,726,84,1,0,0,0,727,728,7,11,0,0,728,86,1,0,0,0,729,730,7,3,0,0, - 730,88,1,0,0,0,731,732,7,12,0,0,732,90,1,0,0,0,733,734,7,13,0,0, - 734,92,1,0,0,0,735,736,7,14,0,0,736,94,1,0,0,0,737,738,7,15,0,0, - 738,96,1,0,0,0,739,740,7,16,0,0,740,98,1,0,0,0,741,742,7,17,0,0, - 742,100,1,0,0,0,743,744,7,18,0,0,744,102,1,0,0,0,745,746,7,19,0, - 0,746,104,1,0,0,0,747,748,7,20,0,0,748,106,1,0,0,0,749,750,7,21, - 0,0,750,108,1,0,0,0,751,752,7,22,0,0,752,110,1,0,0,0,753,754,7,23, - 0,0,754,112,1,0,0,0,755,756,7,24,0,0,756,114,1,0,0,0,757,758,7,25, - 0,0,758,116,1,0,0,0,759,760,7,26,0,0,760,118,1,0,0,0,761,762,7,27, - 0,0,762,120,1,0,0,0,763,764,7,28,0,0,764,122,1,0,0,0,765,766,7,29, - 0,0,766,124,1,0,0,0,767,768,7,30,0,0,768,126,1,0,0,0,769,770,7,31, - 0,0,770,128,1,0,0,0,771,772,7,32,0,0,772,130,1,0,0,0,773,774,7,2, - 0,0,774,132,1,0,0,0,775,784,5,48,0,0,776,780,7,33,0,0,777,779,7, - 2,0,0,778,777,1,0,0,0,779,782,1,0,0,0,780,778,1,0,0,0,780,781,1, - 0,0,0,781,784,1,0,0,0,782,780,1,0,0,0,783,775,1,0,0,0,783,776,1, - 0,0,0,784,134,1,0,0,0,785,786,3,95,47,0,786,787,3,89,44,0,787,136, - 1,0,0,0,788,789,3,117,58,0,789,790,3,93,46,0,790,791,3,87,43,0,791, - 792,3,105,52,0,792,138,1,0,0,0,793,794,3,87,43,0,794,795,3,101,50, - 0,795,796,3,115,57,0,796,797,3,87,43,0,797,140,1,0,0,0,798,799,3, - 81,40,0,799,800,3,107,53,0,800,801,3,107,53,0,801,802,3,101,50,0, - 802,803,3,87,43,0,803,804,3,79,39,0,804,805,3,105,52,0,805,142,1, - 0,0,0,806,807,3,95,47,0,807,808,5,56,0,0,808,144,1,0,0,0,809,810, - 3,95,47,0,810,811,5,49,0,0,811,812,5,54,0,0,812,146,1,0,0,0,813, - 814,3,95,47,0,814,815,5,51,0,0,815,816,5,50,0,0,816,148,1,0,0,0, - 817,818,3,95,47,0,818,819,5,54,0,0,819,820,5,52,0,0,820,150,1,0, - 0,0,821,822,3,89,44,0,822,823,3,109,54,0,823,824,5,51,0,0,824,825, - 5,50,0,0,825,152,1,0,0,0,826,827,3,89,44,0,827,828,3,109,54,0,828, - 829,5,54,0,0,829,830,5,52,0,0,830,154,1,0,0,0,831,832,3,115,57,0, - 832,833,3,117,58,0,833,834,3,113,56,0,834,835,3,95,47,0,835,836, - 3,105,52,0,836,837,3,91,45,0,837,156,1,0,0,0,838,839,3,81,40,0,839, - 840,3,95,47,0,840,841,3,105,52,0,841,842,3,79,39,0,842,843,3,113, - 56,0,843,844,3,127,63,0,844,158,1,0,0,0,845,846,3,117,58,0,846,847, - 3,95,47,0,847,848,3,103,51,0,848,849,3,87,43,0,849,850,3,115,57, - 0,850,851,3,117,58,0,851,852,3,79,39,0,852,853,3,103,51,0,853,854, - 3,109,54,0,854,160,1,0,0,0,855,856,3,117,58,0,856,857,3,95,47,0, - 857,858,3,103,51,0,858,859,3,87,43,0,859,860,3,115,57,0,860,861, - 3,117,58,0,861,862,3,79,39,0,862,863,3,103,51,0,863,864,3,109,54, - 0,864,865,5,95,0,0,865,866,3,117,58,0,866,867,3,129,64,0,867,162, - 1,0,0,0,868,869,3,85,42,0,869,870,3,79,39,0,870,871,3,117,58,0,871, - 872,3,87,43,0,872,164,1,0,0,0,873,874,3,117,58,0,874,875,3,95,47, - 0,875,876,3,103,51,0,876,877,3,87,43,0,877,166,1,0,0,0,878,879,3, - 95,47,0,879,880,3,105,52,0,880,881,3,117,58,0,881,882,3,87,43,0, - 882,883,3,113,56,0,883,884,3,121,60,0,884,885,3,79,39,0,885,886, - 3,101,50,0,886,887,5,95,0,0,887,888,3,127,63,0,888,889,3,87,43,0, - 889,890,3,79,39,0,890,891,3,113,56,0,891,168,1,0,0,0,892,893,3,95, - 47,0,893,894,3,105,52,0,894,895,3,117,58,0,895,896,3,87,43,0,896, - 897,3,113,56,0,897,898,3,121,60,0,898,899,3,79,39,0,899,900,3,101, - 50,0,900,901,5,95,0,0,901,902,3,85,42,0,902,903,3,79,39,0,903,904, - 3,127,63,0,904,170,1,0,0,0,905,906,3,119,59,0,906,907,3,119,59,0, - 907,908,3,95,47,0,908,909,3,85,42,0,909,172,1,0,0,0,910,911,3,85, - 42,0,911,912,3,87,43,0,912,913,3,83,41,0,913,914,3,95,47,0,914,915, - 3,103,51,0,915,916,3,79,39,0,916,917,3,101,50,0,917,174,1,0,0,0, - 918,919,3,109,54,0,919,920,3,113,56,0,920,921,3,87,43,0,921,922, - 3,83,41,0,922,923,3,95,47,0,923,924,3,115,57,0,924,925,3,95,47,0, - 925,926,3,107,53,0,926,927,3,105,52,0,927,928,5,95,0,0,928,929,3, - 117,58,0,929,930,3,95,47,0,930,931,3,103,51,0,931,932,3,87,43,0, - 932,933,3,115,57,0,933,934,3,117,58,0,934,935,3,79,39,0,935,936, - 3,103,51,0,936,937,3,109,54,0,937,176,1,0,0,0,938,939,3,109,54,0, - 939,940,3,113,56,0,940,941,3,87,43,0,941,942,3,83,41,0,942,943,3, - 95,47,0,943,944,3,115,57,0,944,945,3,95,47,0,945,946,3,107,53,0, - 946,947,3,105,52,0,947,948,5,95,0,0,948,949,3,117,58,0,949,950,3, - 95,47,0,950,951,3,103,51,0,951,952,3,87,43,0,952,953,3,115,57,0, - 953,954,3,117,58,0,954,955,3,79,39,0,955,956,3,103,51,0,956,957, - 3,109,54,0,957,958,5,95,0,0,958,959,3,117,58,0,959,960,3,129,64, - 0,960,178,1,0,0,0,961,962,3,89,44,0,962,963,3,95,47,0,963,964,3, - 125,62,0,964,965,3,87,43,0,965,966,3,85,42,0,966,967,3,83,41,0,967, - 968,3,93,46,0,968,969,3,79,39,0,969,970,3,113,56,0,970,180,1,0,0, - 0,971,972,3,121,60,0,972,973,3,79,39,0,973,974,3,113,56,0,974,975, - 3,83,41,0,975,976,3,93,46,0,976,977,3,79,39,0,977,978,3,113,56,0, - 978,182,1,0,0,0,979,980,3,89,44,0,980,981,3,95,47,0,981,982,3,125, - 62,0,982,983,3,87,43,0,983,984,3,85,42,0,984,985,3,81,40,0,985,986, - 3,95,47,0,986,987,3,105,52,0,987,988,3,79,39,0,988,989,3,113,56, - 0,989,990,3,127,63,0,990,184,1,0,0,0,991,992,3,115,57,0,992,993, - 3,117,58,0,993,994,3,113,56,0,994,995,3,119,59,0,995,996,3,83,41, - 0,996,997,3,117,58,0,997,186,1,0,0,0,998,999,3,105,52,0,999,1000, - 3,115,57,0,1000,1001,3,117,58,0,1001,1002,3,113,56,0,1002,1003,3, - 119,59,0,1003,1004,3,83,41,0,1004,1005,3,117,58,0,1005,188,1,0,0, - 0,1006,1007,3,101,50,0,1007,1008,3,95,47,0,1008,1009,3,115,57,0, - 1009,1010,3,117,58,0,1010,190,1,0,0,0,1011,1012,3,103,51,0,1012, - 1013,3,79,39,0,1013,1014,3,109,54,0,1014,192,1,0,0,0,1015,1016,3, - 79,39,0,1016,1017,3,105,52,0,1017,1018,3,127,63,0,1018,194,1,0,0, - 0,1019,1020,3,119,59,0,1020,1021,5,33,0,0,1021,196,1,0,0,0,1022, - 1023,3,91,45,0,1023,1024,3,87,43,0,1024,1025,3,107,53,0,1025,1026, - 3,103,51,0,1026,1027,3,87,43,0,1027,1028,3,117,58,0,1028,1029,3, - 113,56,0,1029,1030,3,127,63,0,1030,198,1,0,0,0,1031,1032,3,81,40, - 0,1032,1033,3,107,53,0,1033,1034,3,107,53,0,1034,1035,3,101,50,0, - 1035,200,1,0,0,0,1036,1037,3,115,57,0,1037,1038,3,117,58,0,1038, - 1039,3,113,56,0,1039,202,1,0,0,0,1040,1041,3,121,60,0,1041,1042, - 3,81,40,0,1042,1043,3,95,47,0,1043,1044,3,105,52,0,1044,204,1,0, - 0,0,1045,1046,3,117,58,0,1046,1047,3,115,57,0,1047,206,1,0,0,0,1048, - 1049,3,117,58,0,1049,1050,3,115,57,0,1050,1051,3,117,58,0,1051,1052, - 3,129,64,0,1052,208,1,0,0,0,1053,1054,3,95,47,0,1054,1055,3,127, - 63,0,1055,1056,3,87,43,0,1056,1057,3,79,39,0,1057,1058,3,113,56, - 0,1058,210,1,0,0,0,1059,1060,3,95,47,0,1060,1061,3,85,42,0,1061, - 1062,3,79,39,0,1062,1063,3,127,63,0,1063,212,1,0,0,0,1064,1065,3, - 85,42,0,1065,1066,3,87,43,0,1066,1067,3,83,41,0,1067,214,1,0,0,0, - 1068,1069,3,109,54,0,1069,1070,3,117,58,0,1070,1071,3,115,57,0,1071, - 216,1,0,0,0,1072,1073,3,109,54,0,1073,1074,3,117,58,0,1074,1075, - 3,115,57,0,1075,1076,3,117,58,0,1076,1077,3,129,64,0,1077,218,1, - 0,0,0,1078,1079,3,89,44,0,1079,1080,3,83,41,0,1080,1081,3,93,46, - 0,1081,1082,3,79,39,0,1082,1083,3,113,56,0,1083,220,1,0,0,0,1084, - 1085,3,121,60,0,1085,1086,3,83,41,0,1086,1087,3,93,46,0,1087,1088, - 3,79,39,0,1088,1089,3,113,56,0,1089,222,1,0,0,0,1090,1091,3,89,44, - 0,1091,1092,3,81,40,0,1092,1093,3,95,47,0,1093,1094,3,105,52,0,1094, - 224,1,0,0,0,1095,1096,5,58,0,0,1096,1097,5,58,0,0,1097,226,1,0,0, - 0,1098,1102,7,34,0,0,1099,1101,7,35,0,0,1100,1099,1,0,0,0,1101,1104, - 1,0,0,0,1102,1100,1,0,0,0,1102,1103,1,0,0,0,1103,228,1,0,0,0,1104, - 1102,1,0,0,0,1105,1106,5,60,0,0,1106,230,1,0,0,0,1107,1108,5,62, - 0,0,1108,232,1,0,0,0,1109,1110,5,40,0,0,1110,234,1,0,0,0,1111,1112, - 5,41,0,0,1112,236,1,0,0,0,1113,1114,5,91,0,0,1114,238,1,0,0,0,1115, - 1116,5,93,0,0,1116,240,1,0,0,0,1117,1118,5,44,0,0,1118,242,1,0,0, - 0,1119,1120,5,61,0,0,1120,244,1,0,0,0,1121,1122,5,58,0,0,1122,246, - 1,0,0,0,1123,1124,5,63,0,0,1124,248,1,0,0,0,1125,1126,5,35,0,0,1126, - 250,1,0,0,0,1127,1128,5,46,0,0,1128,252,1,0,0,0,48,0,284,290,292, - 323,327,410,415,420,426,428,431,436,442,445,449,454,456,459,474, - 485,511,513,537,539,553,555,590,600,609,619,626,631,636,643,648, - 655,660,673,675,686,698,701,706,717,780,783,1102,1,0,1,0 + 4, + 0, + 95, + 1129, + 6, + -1, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 2, + 45, + 7, + 45, + 2, + 46, + 7, + 46, + 2, + 47, + 7, + 47, + 2, + 48, + 7, + 48, + 2, + 49, + 7, + 49, + 2, + 50, + 7, + 50, + 2, + 51, + 7, + 51, + 2, + 52, + 7, + 52, + 2, + 53, + 7, + 53, + 2, + 54, + 7, + 54, + 2, + 55, + 7, + 55, + 2, + 56, + 7, + 56, + 2, + 57, + 7, + 57, + 2, + 58, + 7, + 58, + 2, + 59, + 7, + 59, + 2, + 60, + 7, + 60, + 2, + 61, + 7, + 61, + 2, + 62, + 7, + 62, + 2, + 63, + 7, + 63, + 2, + 64, + 7, + 64, + 2, + 65, + 7, + 65, + 2, + 66, + 7, + 66, + 2, + 67, + 7, + 67, + 2, + 68, + 7, + 68, + 2, + 69, + 7, + 69, + 2, + 70, + 7, + 70, + 2, + 71, + 7, + 71, + 2, + 72, + 7, + 72, + 2, + 73, + 7, + 73, + 2, + 74, + 7, + 74, + 2, + 75, + 7, + 75, + 2, + 76, + 7, + 76, + 2, + 77, + 7, + 77, + 2, + 78, + 7, + 78, + 2, + 79, + 7, + 79, + 2, + 80, + 7, + 80, + 2, + 81, + 7, + 81, + 2, + 82, + 7, + 82, + 2, + 83, + 7, + 83, + 2, + 84, + 7, + 84, + 2, + 85, + 7, + 85, + 2, + 86, + 7, + 86, + 2, + 87, + 7, + 87, + 2, + 88, + 7, + 88, + 2, + 89, + 7, + 89, + 2, + 90, + 7, + 90, + 2, + 91, + 7, + 91, + 2, + 92, + 7, + 92, + 2, + 93, + 7, + 93, + 2, + 94, + 7, + 94, + 2, + 95, + 7, + 95, + 2, + 96, + 7, + 96, + 2, + 97, + 7, + 97, + 2, + 98, + 7, + 98, + 2, + 99, + 7, + 99, + 2, + 100, + 7, + 100, + 2, + 101, + 7, + 101, + 2, + 102, + 7, + 102, + 2, + 103, + 7, + 103, + 2, + 104, + 7, + 104, + 2, + 105, + 7, + 105, + 2, + 106, + 7, + 106, + 2, + 107, + 7, + 107, + 2, + 108, + 7, + 108, + 2, + 109, + 7, + 109, + 2, + 110, + 7, + 110, + 2, + 111, + 7, + 111, + 2, + 112, + 7, + 112, + 2, + 113, + 7, + 113, + 2, + 114, + 7, + 114, + 2, + 115, + 7, + 115, + 2, + 116, + 7, + 116, + 2, + 117, + 7, + 117, + 2, + 118, + 7, + 118, + 2, + 119, + 7, + 119, + 2, + 120, + 7, + 120, + 2, + 121, + 7, + 121, + 2, + 122, + 7, + 122, + 2, + 123, + 7, + 123, + 2, + 124, + 7, + 124, + 2, + 125, + 7, + 125, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 4, + 1, + 283, + 8, + 1, + 11, + 1, + 12, + 1, + 284, + 1, + 1, + 1, + 1, + 4, + 1, + 289, + 8, + 1, + 11, + 1, + 12, + 1, + 290, + 3, + 1, + 293, + 8, + 1, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 5, + 3, + 322, + 8, + 3, + 10, + 3, + 12, + 3, + 325, + 9, + 3, + 1, + 3, + 3, + 3, + 328, + 8, + 3, + 1, + 3, + 1, + 3, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 6, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 7, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 8, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 13, + 3, + 13, + 411, + 8, + 13, + 1, + 13, + 1, + 13, + 1, + 14, + 3, + 14, + 416, + 8, + 14, + 1, + 14, + 4, + 14, + 419, + 8, + 14, + 11, + 14, + 12, + 14, + 420, + 1, + 14, + 1, + 14, + 4, + 14, + 425, + 8, + 14, + 11, + 14, + 12, + 14, + 426, + 3, + 14, + 429, + 8, + 14, + 1, + 15, + 3, + 15, + 432, + 8, + 15, + 1, + 15, + 4, + 15, + 435, + 8, + 15, + 11, + 15, + 12, + 15, + 436, + 1, + 15, + 1, + 15, + 5, + 15, + 441, + 8, + 15, + 10, + 15, + 12, + 15, + 444, + 9, + 15, + 3, + 15, + 446, + 8, + 15, + 1, + 15, + 1, + 15, + 3, + 15, + 450, + 8, + 15, + 1, + 15, + 4, + 15, + 453, + 8, + 15, + 11, + 15, + 12, + 15, + 454, + 3, + 15, + 457, + 8, + 15, + 1, + 15, + 3, + 15, + 460, + 8, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 3, + 15, + 475, + 8, + 15, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 3, + 16, + 486, + 8, + 16, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 4, + 19, + 510, + 8, + 19, + 11, + 19, + 12, + 19, + 511, + 3, + 19, + 514, + 8, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 4, + 20, + 536, + 8, + 20, + 11, + 20, + 12, + 20, + 537, + 3, + 20, + 540, + 8, + 20, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 4, + 21, + 552, + 8, + 21, + 11, + 21, + 12, + 21, + 553, + 3, + 21, + 556, + 8, + 21, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 591, + 8, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 601, + 8, + 31, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 610, + 8, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 3, + 32, + 620, + 8, + 32, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 627, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 632, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 637, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 644, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 649, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 656, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 3, + 33, + 661, + 8, + 33, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 5, + 35, + 674, + 8, + 35, + 10, + 35, + 12, + 35, + 677, + 9, + 35, + 1, + 35, + 1, + 35, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 5, + 36, + 685, + 8, + 36, + 10, + 36, + 12, + 36, + 688, + 9, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 4, + 37, + 697, + 8, + 37, + 11, + 37, + 12, + 37, + 698, + 1, + 37, + 3, + 37, + 702, + 8, + 37, + 1, + 37, + 5, + 37, + 705, + 8, + 37, + 10, + 37, + 12, + 37, + 708, + 9, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 4, + 38, + 716, + 8, + 38, + 11, + 38, + 12, + 38, + 717, + 1, + 38, + 1, + 38, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, + 1, + 46, + 1, + 46, + 1, + 47, + 1, + 47, + 1, + 48, + 1, + 48, + 1, + 49, + 1, + 49, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 52, + 1, + 52, + 1, + 53, + 1, + 53, + 1, + 54, + 1, + 54, + 1, + 55, + 1, + 55, + 1, + 56, + 1, + 56, + 1, + 57, + 1, + 57, + 1, + 58, + 1, + 58, + 1, + 59, + 1, + 59, + 1, + 60, + 1, + 60, + 1, + 61, + 1, + 61, + 1, + 62, + 1, + 62, + 1, + 63, + 1, + 63, + 1, + 64, + 1, + 64, + 1, + 65, + 1, + 65, + 1, + 66, + 1, + 66, + 1, + 66, + 5, + 66, + 779, + 8, + 66, + 10, + 66, + 12, + 66, + 782, + 9, + 66, + 3, + 66, + 784, + 8, + 66, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 77, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 78, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 79, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 81, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 82, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 83, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 84, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 85, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 86, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 87, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 88, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 89, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 90, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 91, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 92, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 93, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 94, + 1, + 95, + 1, + 95, + 1, + 95, + 1, + 95, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 96, + 1, + 97, + 1, + 97, + 1, + 97, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 98, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 99, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 100, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 101, + 1, + 102, + 1, + 102, + 1, + 102, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 103, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 104, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 105, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 106, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 107, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 108, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 109, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 110, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 111, + 1, + 112, + 1, + 112, + 1, + 112, + 1, + 113, + 1, + 113, + 5, + 113, + 1101, + 8, + 113, + 10, + 113, + 12, + 113, + 1104, + 9, + 113, + 1, + 114, + 1, + 114, + 1, + 115, + 1, + 115, + 1, + 116, + 1, + 116, + 1, + 117, + 1, + 117, + 1, + 118, + 1, + 118, + 1, + 119, + 1, + 119, + 1, + 120, + 1, + 120, + 1, + 121, + 1, + 121, + 1, + 122, + 1, + 122, + 1, + 123, + 1, + 123, + 1, + 124, + 1, + 124, + 1, + 125, + 1, + 125, + 0, + 0, + 126, + 1, + 1, + 3, + 2, + 5, + 3, + 7, + 4, + 9, + 5, + 11, + 6, + 13, + 7, + 15, + 8, + 17, + 9, + 19, + 10, + 21, + 11, + 23, + 12, + 25, + 13, + 27, + 14, + 29, + 15, + 31, + 16, + 33, + 17, + 35, + 0, + 37, + 0, + 39, + 18, + 41, + 19, + 43, + 20, + 45, + 21, + 47, + 22, + 49, + 23, + 51, + 24, + 53, + 25, + 55, + 26, + 57, + 27, + 59, + 28, + 61, + 29, + 63, + 30, + 65, + 31, + 67, + 0, + 69, + 32, + 71, + 33, + 73, + 34, + 75, + 35, + 77, + 36, + 79, + 0, + 81, + 0, + 83, + 0, + 85, + 0, + 87, + 0, + 89, + 0, + 91, + 0, + 93, + 0, + 95, + 0, + 97, + 0, + 99, + 0, + 101, + 0, + 103, + 0, + 105, + 0, + 107, + 0, + 109, + 0, + 111, + 0, + 113, + 0, + 115, + 0, + 117, + 0, + 119, + 0, + 121, + 0, + 123, + 0, + 125, + 0, + 127, + 0, + 129, + 0, + 131, + 0, + 133, + 0, + 135, + 37, + 137, + 38, + 139, + 39, + 141, + 40, + 143, + 41, + 145, + 42, + 147, + 43, + 149, + 44, + 151, + 45, + 153, + 46, + 155, + 47, + 157, + 48, + 159, + 49, + 161, + 50, + 163, + 51, + 165, + 52, + 167, + 53, + 169, + 54, + 171, + 55, + 173, + 56, + 175, + 57, + 177, + 58, + 179, + 59, + 181, + 60, + 183, + 61, + 185, + 62, + 187, + 63, + 189, + 64, + 191, + 65, + 193, + 66, + 195, + 67, + 197, + 68, + 199, + 69, + 201, + 70, + 203, + 71, + 205, + 72, + 207, + 73, + 209, + 74, + 211, + 75, + 213, + 76, + 215, + 77, + 217, + 78, + 219, + 79, + 221, + 80, + 223, + 81, + 225, + 82, + 227, + 83, + 229, + 84, + 231, + 85, + 233, + 86, + 235, + 87, + 237, + 88, + 239, + 89, + 241, + 90, + 243, + 91, + 245, + 92, + 247, + 93, + 249, + 94, + 251, + 95, + 1, + 0, + 36, + 2, + 0, + 10, + 10, + 13, + 13, + 2, + 0, + 43, + 43, + 45, + 45, + 1, + 0, + 48, + 57, + 2, + 0, + 69, + 69, + 101, + 101, + 2, + 0, + 39, + 39, + 92, + 92, + 1, + 0, + 42, + 42, + 2, + 0, + 42, + 42, + 47, + 47, + 3, + 0, + 9, + 10, + 13, + 13, + 32, + 32, + 2, + 0, + 65, + 65, + 97, + 97, + 2, + 0, + 66, + 66, + 98, + 98, + 2, + 0, + 67, + 67, + 99, + 99, + 2, + 0, + 68, + 68, + 100, + 100, + 2, + 0, + 70, + 70, + 102, + 102, + 2, + 0, + 71, + 71, + 103, + 103, + 2, + 0, + 72, + 72, + 104, + 104, + 2, + 0, + 73, + 73, + 105, + 105, + 2, + 0, + 74, + 74, + 106, + 106, + 2, + 0, + 75, + 75, + 107, + 107, + 2, + 0, + 76, + 76, + 108, + 108, + 2, + 0, + 77, + 77, + 109, + 109, + 2, + 0, + 78, + 78, + 110, + 110, + 2, + 0, + 79, + 79, + 111, + 111, + 2, + 0, + 80, + 80, + 112, + 112, + 2, + 0, + 81, + 81, + 113, + 113, + 2, + 0, + 82, + 82, + 114, + 114, + 2, + 0, + 83, + 83, + 115, + 115, + 2, + 0, + 84, + 84, + 116, + 116, + 2, + 0, + 85, + 85, + 117, + 117, + 2, + 0, + 86, + 86, + 118, + 118, + 2, + 0, + 87, + 87, + 119, + 119, + 2, + 0, + 88, + 88, + 120, + 120, + 2, + 0, + 89, + 89, + 121, + 121, + 2, + 0, + 90, + 90, + 122, + 122, + 1, + 0, + 49, + 57, + 3, + 0, + 65, + 90, + 95, + 95, + 97, + 122, + 4, + 0, + 48, + 57, + 65, + 90, + 95, + 95, + 97, + 122, + 1150, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 5, + 1, + 0, + 0, + 0, + 0, + 7, + 1, + 0, + 0, + 0, + 0, + 9, + 1, + 0, + 0, + 0, + 0, + 11, + 1, + 0, + 0, + 0, + 0, + 13, + 1, + 0, + 0, + 0, + 0, + 15, + 1, + 0, + 0, + 0, + 0, + 17, + 1, + 0, + 0, + 0, + 0, + 19, + 1, + 0, + 0, + 0, + 0, + 21, + 1, + 0, + 0, + 0, + 0, + 23, + 1, + 0, + 0, + 0, + 0, + 25, + 1, + 0, + 0, + 0, + 0, + 27, + 1, + 0, + 0, + 0, + 0, + 29, + 1, + 0, + 0, + 0, + 0, + 31, + 1, + 0, + 0, + 0, + 0, + 33, + 1, + 0, + 0, + 0, + 0, + 39, + 1, + 0, + 0, + 0, + 0, + 41, + 1, + 0, + 0, + 0, + 0, + 43, + 1, + 0, + 0, + 0, + 0, + 45, + 1, + 0, + 0, + 0, + 0, + 47, + 1, + 0, + 0, + 0, + 0, + 49, + 1, + 0, + 0, + 0, + 0, + 51, + 1, + 0, + 0, + 0, + 0, + 53, + 1, + 0, + 0, + 0, + 0, + 55, + 1, + 0, + 0, + 0, + 0, + 57, + 1, + 0, + 0, + 0, + 0, + 59, + 1, + 0, + 0, + 0, + 0, + 61, + 1, + 0, + 0, + 0, + 0, + 63, + 1, + 0, + 0, + 0, + 0, + 65, + 1, + 0, + 0, + 0, + 0, + 69, + 1, + 0, + 0, + 0, + 0, + 71, + 1, + 0, + 0, + 0, + 0, + 73, + 1, + 0, + 0, + 0, + 0, + 75, + 1, + 0, + 0, + 0, + 0, + 77, + 1, + 0, + 0, + 0, + 0, + 135, + 1, + 0, + 0, + 0, + 0, + 137, + 1, + 0, + 0, + 0, + 0, + 139, + 1, + 0, + 0, + 0, + 0, + 141, + 1, + 0, + 0, + 0, + 0, + 143, + 1, + 0, + 0, + 0, + 0, + 145, + 1, + 0, + 0, + 0, + 0, + 147, + 1, + 0, + 0, + 0, + 0, + 149, + 1, + 0, + 0, + 0, + 0, + 151, + 1, + 0, + 0, + 0, + 0, + 153, + 1, + 0, + 0, + 0, + 0, + 155, + 1, + 0, + 0, + 0, + 0, + 157, + 1, + 0, + 0, + 0, + 0, + 159, + 1, + 0, + 0, + 0, + 0, + 161, + 1, + 0, + 0, + 0, + 0, + 163, + 1, + 0, + 0, + 0, + 0, + 165, + 1, + 0, + 0, + 0, + 0, + 167, + 1, + 0, + 0, + 0, + 0, + 169, + 1, + 0, + 0, + 0, + 0, + 171, + 1, + 0, + 0, + 0, + 0, + 173, + 1, + 0, + 0, + 0, + 0, + 175, + 1, + 0, + 0, + 0, + 0, + 177, + 1, + 0, + 0, + 0, + 0, + 179, + 1, + 0, + 0, + 0, + 0, + 181, + 1, + 0, + 0, + 0, + 0, + 183, + 1, + 0, + 0, + 0, + 0, + 185, + 1, + 0, + 0, + 0, + 0, + 187, + 1, + 0, + 0, + 0, + 0, + 189, + 1, + 0, + 0, + 0, + 0, + 191, + 1, + 0, + 0, + 0, + 0, + 193, + 1, + 0, + 0, + 0, + 0, + 195, + 1, + 0, + 0, + 0, + 0, + 197, + 1, + 0, + 0, + 0, + 0, + 199, + 1, + 0, + 0, + 0, + 0, + 201, + 1, + 0, + 0, + 0, + 0, + 203, + 1, + 0, + 0, + 0, + 0, + 205, + 1, + 0, + 0, + 0, + 0, + 207, + 1, + 0, + 0, + 0, + 0, + 209, + 1, + 0, + 0, + 0, + 0, + 211, + 1, + 0, + 0, + 0, + 0, + 213, + 1, + 0, + 0, + 0, + 0, + 215, + 1, + 0, + 0, + 0, + 0, + 217, + 1, + 0, + 0, + 0, + 0, + 219, + 1, + 0, + 0, + 0, + 0, + 221, + 1, + 0, + 0, + 0, + 0, + 223, + 1, + 0, + 0, + 0, + 0, + 225, + 1, + 0, + 0, + 0, + 0, + 227, + 1, + 0, + 0, + 0, + 0, + 229, + 1, + 0, + 0, + 0, + 0, + 231, + 1, + 0, + 0, + 0, + 0, + 233, + 1, + 0, + 0, + 0, + 0, + 235, + 1, + 0, + 0, + 0, + 0, + 237, + 1, + 0, + 0, + 0, + 0, + 239, + 1, + 0, + 0, + 0, + 0, + 241, + 1, + 0, + 0, + 0, + 0, + 243, + 1, + 0, + 0, + 0, + 0, + 245, + 1, + 0, + 0, + 0, + 0, + 247, + 1, + 0, + 0, + 0, + 0, + 249, + 1, + 0, + 0, + 0, + 0, + 251, + 1, + 0, + 0, + 0, + 1, + 253, + 1, + 0, + 0, + 0, + 3, + 280, + 1, + 0, + 0, + 0, + 5, + 294, + 1, + 0, + 0, + 0, + 7, + 317, + 1, + 0, + 0, + 0, + 9, + 331, + 1, + 0, + 0, + 0, + 11, + 340, + 1, + 0, + 0, + 0, + 13, + 353, + 1, + 0, + 0, + 0, + 15, + 362, + 1, + 0, + 0, + 0, + 17, + 371, + 1, + 0, + 0, + 0, + 19, + 377, + 1, + 0, + 0, + 0, + 21, + 386, + 1, + 0, + 0, + 0, + 23, + 393, + 1, + 0, + 0, + 0, + 25, + 405, + 1, + 0, + 0, + 0, + 27, + 410, + 1, + 0, + 0, + 0, + 29, + 415, + 1, + 0, + 0, + 0, + 31, + 474, + 1, + 0, + 0, + 0, + 33, + 485, + 1, + 0, + 0, + 0, + 35, + 487, + 1, + 0, + 0, + 0, + 37, + 492, + 1, + 0, + 0, + 0, + 39, + 495, + 1, + 0, + 0, + 0, + 41, + 521, + 1, + 0, + 0, + 0, + 43, + 543, + 1, + 0, + 0, + 0, + 45, + 559, + 1, + 0, + 0, + 0, + 47, + 567, + 1, + 0, + 0, + 0, + 49, + 569, + 1, + 0, + 0, + 0, + 51, + 571, + 1, + 0, + 0, + 0, + 53, + 573, + 1, + 0, + 0, + 0, + 55, + 575, + 1, + 0, + 0, + 0, + 57, + 577, + 1, + 0, + 0, + 0, + 59, + 579, + 1, + 0, + 0, + 0, + 61, + 581, + 1, + 0, + 0, + 0, + 63, + 600, + 1, + 0, + 0, + 0, + 65, + 619, + 1, + 0, + 0, + 0, + 67, + 660, + 1, + 0, + 0, + 0, + 69, + 662, + 1, + 0, + 0, + 0, + 71, + 667, + 1, + 0, + 0, + 0, + 73, + 680, + 1, + 0, + 0, + 0, + 75, + 691, + 1, + 0, + 0, + 0, + 77, + 715, + 1, + 0, + 0, + 0, + 79, + 721, + 1, + 0, + 0, + 0, + 81, + 723, + 1, + 0, + 0, + 0, + 83, + 725, + 1, + 0, + 0, + 0, + 85, + 727, + 1, + 0, + 0, + 0, + 87, + 729, + 1, + 0, + 0, + 0, + 89, + 731, + 1, + 0, + 0, + 0, + 91, + 733, + 1, + 0, + 0, + 0, + 93, + 735, + 1, + 0, + 0, + 0, + 95, + 737, + 1, + 0, + 0, + 0, + 97, + 739, + 1, + 0, + 0, + 0, + 99, + 741, + 1, + 0, + 0, + 0, + 101, + 743, + 1, + 0, + 0, + 0, + 103, + 745, + 1, + 0, + 0, + 0, + 105, + 747, + 1, + 0, + 0, + 0, + 107, + 749, + 1, + 0, + 0, + 0, + 109, + 751, + 1, + 0, + 0, + 0, + 111, + 753, + 1, + 0, + 0, + 0, + 113, + 755, + 1, + 0, + 0, + 0, + 115, + 757, + 1, + 0, + 0, + 0, + 117, + 759, + 1, + 0, + 0, + 0, + 119, + 761, + 1, + 0, + 0, + 0, + 121, + 763, + 1, + 0, + 0, + 0, + 123, + 765, + 1, + 0, + 0, + 0, + 125, + 767, + 1, + 0, + 0, + 0, + 127, + 769, + 1, + 0, + 0, + 0, + 129, + 771, + 1, + 0, + 0, + 0, + 131, + 773, + 1, + 0, + 0, + 0, + 133, + 783, + 1, + 0, + 0, + 0, + 135, + 785, + 1, + 0, + 0, + 0, + 137, + 788, + 1, + 0, + 0, + 0, + 139, + 793, + 1, + 0, + 0, + 0, + 141, + 798, + 1, + 0, + 0, + 0, + 143, + 806, + 1, + 0, + 0, + 0, + 145, + 809, + 1, + 0, + 0, + 0, + 147, + 813, + 1, + 0, + 0, + 0, + 149, + 817, + 1, + 0, + 0, + 0, + 151, + 821, + 1, + 0, + 0, + 0, + 153, + 826, + 1, + 0, + 0, + 0, + 155, + 831, + 1, + 0, + 0, + 0, + 157, + 838, + 1, + 0, + 0, + 0, + 159, + 845, + 1, + 0, + 0, + 0, + 161, + 855, + 1, + 0, + 0, + 0, + 163, + 868, + 1, + 0, + 0, + 0, + 165, + 873, + 1, + 0, + 0, + 0, + 167, + 878, + 1, + 0, + 0, + 0, + 169, + 892, + 1, + 0, + 0, + 0, + 171, + 905, + 1, + 0, + 0, + 0, + 173, + 910, + 1, + 0, + 0, + 0, + 175, + 918, + 1, + 0, + 0, + 0, + 177, + 938, + 1, + 0, + 0, + 0, + 179, + 961, + 1, + 0, + 0, + 0, + 181, + 971, + 1, + 0, + 0, + 0, + 183, + 979, + 1, + 0, + 0, + 0, + 185, + 991, + 1, + 0, + 0, + 0, + 187, + 998, + 1, + 0, + 0, + 0, + 189, + 1006, + 1, + 0, + 0, + 0, + 191, + 1011, + 1, + 0, + 0, + 0, + 193, + 1015, + 1, + 0, + 0, + 0, + 195, + 1019, + 1, + 0, + 0, + 0, + 197, + 1022, + 1, + 0, + 0, + 0, + 199, + 1031, + 1, + 0, + 0, + 0, + 201, + 1036, + 1, + 0, + 0, + 0, + 203, + 1040, + 1, + 0, + 0, + 0, + 205, + 1045, + 1, + 0, + 0, + 0, + 207, + 1048, + 1, + 0, + 0, + 0, + 209, + 1053, + 1, + 0, + 0, + 0, + 211, + 1059, + 1, + 0, + 0, + 0, + 213, + 1064, + 1, + 0, + 0, + 0, + 215, + 1068, + 1, + 0, + 0, + 0, + 217, + 1072, + 1, + 0, + 0, + 0, + 219, + 1078, + 1, + 0, + 0, + 0, + 221, + 1084, + 1, + 0, + 0, + 0, + 223, + 1090, + 1, + 0, + 0, + 0, + 225, + 1095, + 1, + 0, + 0, + 0, + 227, + 1098, + 1, + 0, + 0, + 0, + 229, + 1105, + 1, + 0, + 0, + 0, + 231, + 1107, + 1, + 0, + 0, + 0, + 233, + 1109, + 1, + 0, + 0, + 0, + 235, + 1111, + 1, + 0, + 0, + 0, + 237, + 1113, + 1, + 0, + 0, + 0, + 239, + 1115, + 1, + 0, + 0, + 0, + 241, + 1117, + 1, + 0, + 0, + 0, + 243, + 1119, + 1, + 0, + 0, + 0, + 245, + 1121, + 1, + 0, + 0, + 0, + 247, + 1123, + 1, + 0, + 0, + 0, + 249, + 1125, + 1, + 0, + 0, + 0, + 251, + 1127, + 1, + 0, + 0, + 0, + 253, + 254, + 5, + 35, + 0, + 0, + 254, + 255, + 5, + 35, + 0, + 0, + 255, + 256, + 5, + 35, + 0, + 0, + 256, + 257, + 5, + 32, + 0, + 0, + 257, + 258, + 5, + 83, + 0, + 0, + 258, + 259, + 5, + 85, + 0, + 0, + 259, + 260, + 5, + 66, + 0, + 0, + 260, + 261, + 5, + 83, + 0, + 0, + 261, + 262, + 5, + 84, + 0, + 0, + 262, + 263, + 5, + 82, + 0, + 0, + 263, + 264, + 5, + 65, + 0, + 0, + 264, + 265, + 5, + 73, + 0, + 0, + 265, + 266, + 5, + 84, + 0, + 0, + 266, + 267, + 5, + 95, + 0, + 0, + 267, + 268, + 5, + 83, + 0, + 0, + 268, + 269, + 5, + 67, + 0, + 0, + 269, + 270, + 5, + 65, + 0, + 0, + 270, + 271, + 5, + 76, + 0, + 0, + 271, + 272, + 5, + 65, + 0, + 0, + 272, + 273, + 5, + 82, + 0, + 0, + 273, + 274, + 5, + 95, + 0, + 0, + 274, + 275, + 5, + 84, + 0, + 0, + 275, + 276, + 5, + 69, + 0, + 0, + 276, + 277, + 5, + 83, + 0, + 0, + 277, + 278, + 5, + 84, + 0, + 0, + 278, + 279, + 5, + 58, + 0, + 0, + 279, + 2, + 1, + 0, + 0, + 0, + 280, + 282, + 5, + 118, + 0, + 0, + 281, + 283, + 3, + 131, + 65, + 0, + 282, + 281, + 1, + 0, + 0, + 0, + 283, + 284, + 1, + 0, + 0, + 0, + 284, + 282, + 1, + 0, + 0, + 0, + 284, + 285, + 1, + 0, + 0, + 0, + 285, + 292, + 1, + 0, + 0, + 0, + 286, + 288, + 5, + 46, + 0, + 0, + 287, + 289, + 3, + 131, + 65, + 0, + 288, + 287, + 1, + 0, + 0, + 0, + 289, + 290, + 1, + 0, + 0, + 0, + 290, + 288, + 1, + 0, + 0, + 0, + 290, + 291, + 1, + 0, + 0, + 0, + 291, + 293, + 1, + 0, + 0, + 0, + 292, + 286, + 1, + 0, + 0, + 0, + 292, + 293, + 1, + 0, + 0, + 0, + 293, + 4, + 1, + 0, + 0, + 0, + 294, + 295, + 5, + 35, + 0, + 0, + 295, + 296, + 5, + 35, + 0, + 0, + 296, + 297, + 5, + 35, + 0, + 0, + 297, + 298, + 5, + 32, + 0, + 0, + 298, + 299, + 5, + 83, + 0, + 0, + 299, + 300, + 5, + 85, + 0, + 0, + 300, + 301, + 5, + 66, + 0, + 0, + 301, + 302, + 5, + 83, + 0, + 0, + 302, + 303, + 5, + 84, + 0, + 0, + 303, + 304, + 5, + 82, + 0, + 0, + 304, + 305, + 5, + 65, + 0, + 0, + 305, + 306, + 5, + 73, + 0, + 0, + 306, + 307, + 5, + 84, + 0, + 0, + 307, + 308, + 5, + 95, + 0, + 0, + 308, + 309, + 5, + 73, + 0, + 0, + 309, + 310, + 5, + 78, + 0, + 0, + 310, + 311, + 5, + 67, + 0, + 0, + 311, + 312, + 5, + 76, + 0, + 0, + 312, + 313, + 5, + 85, + 0, + 0, + 313, + 314, + 5, + 68, + 0, + 0, + 314, + 315, + 5, + 69, + 0, + 0, + 315, + 316, + 5, + 58, + 0, + 0, + 316, + 6, + 1, + 0, + 0, + 0, + 317, + 318, + 5, + 35, + 0, + 0, + 318, + 319, + 5, + 32, + 0, + 0, + 319, + 323, + 1, + 0, + 0, + 0, + 320, + 322, + 8, + 0, + 0, + 0, + 321, + 320, + 1, + 0, + 0, + 0, + 322, + 325, + 1, + 0, + 0, + 0, + 323, + 321, + 1, + 0, + 0, + 0, + 323, + 324, + 1, + 0, + 0, + 0, + 324, + 327, + 1, + 0, + 0, + 0, + 325, + 323, + 1, + 0, + 0, + 0, + 326, + 328, + 5, + 13, + 0, + 0, + 327, + 326, + 1, + 0, + 0, + 0, + 327, + 328, + 1, + 0, + 0, + 0, + 328, + 329, + 1, + 0, + 0, + 0, + 329, + 330, + 5, + 10, + 0, + 0, + 330, + 8, + 1, + 0, + 0, + 0, + 331, + 332, + 5, + 60, + 0, + 0, + 332, + 333, + 5, + 33, + 0, + 0, + 333, + 334, + 5, + 69, + 0, + 0, + 334, + 335, + 5, + 82, + 0, + 0, + 335, + 336, + 5, + 82, + 0, + 0, + 336, + 337, + 5, + 79, + 0, + 0, + 337, + 338, + 5, + 82, + 0, + 0, + 338, + 339, + 5, + 62, + 0, + 0, + 339, + 10, + 1, + 0, + 0, + 0, + 340, + 341, + 5, + 60, + 0, + 0, + 341, + 342, + 5, + 33, + 0, + 0, + 342, + 343, + 5, + 85, + 0, + 0, + 343, + 344, + 5, + 78, + 0, + 0, + 344, + 345, + 5, + 68, + 0, + 0, + 345, + 346, + 5, + 69, + 0, + 0, + 346, + 347, + 5, + 70, + 0, + 0, + 347, + 348, + 5, + 73, + 0, + 0, + 348, + 349, + 5, + 78, + 0, + 0, + 349, + 350, + 5, + 69, + 0, + 0, + 350, + 351, + 5, + 68, + 0, + 0, + 351, + 352, + 5, + 62, + 0, + 0, + 352, + 12, + 1, + 0, + 0, + 0, + 353, + 354, + 5, + 111, + 0, + 0, + 354, + 355, + 5, + 118, + 0, + 0, + 355, + 356, + 5, + 101, + 0, + 0, + 356, + 357, + 5, + 114, + 0, + 0, + 357, + 358, + 5, + 108, + 0, + 0, + 358, + 359, + 5, + 102, + 0, + 0, + 359, + 360, + 5, + 111, + 0, + 0, + 360, + 361, + 5, + 119, + 0, + 0, + 361, + 14, + 1, + 0, + 0, + 0, + 362, + 363, + 5, + 114, + 0, + 0, + 363, + 364, + 5, + 111, + 0, + 0, + 364, + 365, + 5, + 117, + 0, + 0, + 365, + 366, + 5, + 110, + 0, + 0, + 366, + 367, + 5, + 100, + 0, + 0, + 367, + 368, + 5, + 105, + 0, + 0, + 368, + 369, + 5, + 110, + 0, + 0, + 369, + 370, + 5, + 103, + 0, + 0, + 370, + 16, + 1, + 0, + 0, + 0, + 371, + 372, + 5, + 69, + 0, + 0, + 372, + 373, + 5, + 82, + 0, + 0, + 373, + 374, + 5, + 82, + 0, + 0, + 374, + 375, + 5, + 79, + 0, + 0, + 375, + 376, + 5, + 82, + 0, + 0, + 376, + 18, + 1, + 0, + 0, + 0, + 377, + 378, + 5, + 83, + 0, + 0, + 378, + 379, + 5, + 65, + 0, + 0, + 379, + 380, + 5, + 84, + 0, + 0, + 380, + 381, + 5, + 85, + 0, + 0, + 381, + 382, + 5, + 82, + 0, + 0, + 382, + 383, + 5, + 65, + 0, + 0, + 383, + 384, + 5, + 84, + 0, + 0, + 384, + 385, + 5, + 69, + 0, + 0, + 385, + 20, + 1, + 0, + 0, + 0, + 386, + 387, + 5, + 83, + 0, + 0, + 387, + 388, + 5, + 73, + 0, + 0, + 388, + 389, + 5, + 76, + 0, + 0, + 389, + 390, + 5, + 69, + 0, + 0, + 390, + 391, + 5, + 78, + 0, + 0, + 391, + 392, + 5, + 84, + 0, + 0, + 392, + 22, + 1, + 0, + 0, + 0, + 393, + 394, + 5, + 84, + 0, + 0, + 394, + 395, + 5, + 73, + 0, + 0, + 395, + 396, + 5, + 69, + 0, + 0, + 396, + 397, + 5, + 95, + 0, + 0, + 397, + 398, + 5, + 84, + 0, + 0, + 398, + 399, + 5, + 79, + 0, + 0, + 399, + 400, + 5, + 95, + 0, + 0, + 400, + 401, + 5, + 69, + 0, + 0, + 401, + 402, + 5, + 86, + 0, + 0, + 402, + 403, + 5, + 69, + 0, + 0, + 403, + 404, + 5, + 78, + 0, + 0, + 404, + 24, + 1, + 0, + 0, + 0, + 405, + 406, + 5, + 78, + 0, + 0, + 406, + 407, + 5, + 65, + 0, + 0, + 407, + 408, + 5, + 78, + 0, + 0, + 408, + 26, + 1, + 0, + 0, + 0, + 409, + 411, + 7, + 1, + 0, + 0, + 410, + 409, + 1, + 0, + 0, + 0, + 410, + 411, + 1, + 0, + 0, + 0, + 411, + 412, + 1, + 0, + 0, + 0, + 412, + 413, + 3, + 133, + 66, + 0, + 413, + 28, + 1, + 0, + 0, + 0, + 414, + 416, + 7, + 1, + 0, + 0, + 415, + 414, + 1, + 0, + 0, + 0, + 415, + 416, + 1, + 0, + 0, + 0, + 416, + 418, + 1, + 0, + 0, + 0, + 417, + 419, + 7, + 2, + 0, + 0, + 418, + 417, + 1, + 0, + 0, + 0, + 419, + 420, + 1, + 0, + 0, + 0, + 420, + 418, + 1, + 0, + 0, + 0, + 420, + 421, + 1, + 0, + 0, + 0, + 421, + 428, + 1, + 0, + 0, + 0, + 422, + 424, + 5, + 46, + 0, + 0, + 423, + 425, + 7, + 2, + 0, + 0, + 424, + 423, + 1, + 0, + 0, + 0, + 425, + 426, + 1, + 0, + 0, + 0, + 426, + 424, + 1, + 0, + 0, + 0, + 426, + 427, + 1, + 0, + 0, + 0, + 427, + 429, + 1, + 0, + 0, + 0, + 428, + 422, + 1, + 0, + 0, + 0, + 428, + 429, + 1, + 0, + 0, + 0, + 429, + 30, + 1, + 0, + 0, + 0, + 430, + 432, + 7, + 1, + 0, + 0, + 431, + 430, + 1, + 0, + 0, + 0, + 431, + 432, + 1, + 0, + 0, + 0, + 432, + 434, + 1, + 0, + 0, + 0, + 433, + 435, + 7, + 2, + 0, + 0, + 434, + 433, + 1, + 0, + 0, + 0, + 435, + 436, + 1, + 0, + 0, + 0, + 436, + 434, + 1, + 0, + 0, + 0, + 436, + 437, + 1, + 0, + 0, + 0, + 437, + 445, + 1, + 0, + 0, + 0, + 438, + 442, + 5, + 46, + 0, + 0, + 439, + 441, + 7, + 2, + 0, + 0, + 440, + 439, + 1, + 0, + 0, + 0, + 441, + 444, + 1, + 0, + 0, + 0, + 442, + 440, + 1, + 0, + 0, + 0, + 442, + 443, + 1, + 0, + 0, + 0, + 443, + 446, + 1, + 0, + 0, + 0, + 444, + 442, + 1, + 0, + 0, + 0, + 445, + 438, + 1, + 0, + 0, + 0, + 445, + 446, + 1, + 0, + 0, + 0, + 446, + 456, + 1, + 0, + 0, + 0, + 447, + 449, + 7, + 3, + 0, + 0, + 448, + 450, + 7, + 1, + 0, + 0, + 449, + 448, + 1, + 0, + 0, + 0, + 449, + 450, + 1, + 0, + 0, + 0, + 450, + 452, + 1, + 0, + 0, + 0, + 451, + 453, + 7, + 2, + 0, + 0, + 452, + 451, + 1, + 0, + 0, + 0, + 453, + 454, + 1, + 0, + 0, + 0, + 454, + 452, + 1, + 0, + 0, + 0, + 454, + 455, + 1, + 0, + 0, + 0, + 455, + 457, + 1, + 0, + 0, + 0, + 456, + 447, + 1, + 0, + 0, + 0, + 456, + 457, + 1, + 0, + 0, + 0, + 457, + 475, + 1, + 0, + 0, + 0, + 458, + 460, + 7, + 1, + 0, + 0, + 459, + 458, + 1, + 0, + 0, + 0, + 459, + 460, + 1, + 0, + 0, + 0, + 460, + 461, + 1, + 0, + 0, + 0, + 461, + 462, + 5, + 105, + 0, + 0, + 462, + 463, + 5, + 110, + 0, + 0, + 463, + 475, + 5, + 102, + 0, + 0, + 464, + 465, + 5, + 110, + 0, + 0, + 465, + 466, + 5, + 97, + 0, + 0, + 466, + 475, + 5, + 110, + 0, + 0, + 467, + 468, + 5, + 78, + 0, + 0, + 468, + 469, + 5, + 97, + 0, + 0, + 469, + 475, + 5, + 78, + 0, + 0, + 470, + 471, + 5, + 115, + 0, + 0, + 471, + 472, + 5, + 110, + 0, + 0, + 472, + 473, + 5, + 97, + 0, + 0, + 473, + 475, + 5, + 110, + 0, + 0, + 474, + 431, + 1, + 0, + 0, + 0, + 474, + 459, + 1, + 0, + 0, + 0, + 474, + 464, + 1, + 0, + 0, + 0, + 474, + 467, + 1, + 0, + 0, + 0, + 474, + 470, + 1, + 0, + 0, + 0, + 475, + 32, + 1, + 0, + 0, + 0, + 476, + 477, + 5, + 116, + 0, + 0, + 477, + 478, + 5, + 114, + 0, + 0, + 478, + 479, + 5, + 117, + 0, + 0, + 479, + 486, + 5, + 101, + 0, + 0, + 480, + 481, + 5, + 102, + 0, + 0, + 481, + 482, + 5, + 97, + 0, + 0, + 482, + 483, + 5, + 108, + 0, + 0, + 483, + 484, + 5, + 115, + 0, + 0, + 484, + 486, + 5, + 101, + 0, + 0, + 485, + 476, + 1, + 0, + 0, + 0, + 485, + 480, + 1, + 0, + 0, + 0, + 486, + 34, + 1, + 0, + 0, + 0, + 487, + 488, + 7, + 2, + 0, + 0, + 488, + 489, + 7, + 2, + 0, + 0, + 489, + 490, + 7, + 2, + 0, + 0, + 490, + 491, + 7, + 2, + 0, + 0, + 491, + 36, + 1, + 0, + 0, + 0, + 492, + 493, + 7, + 2, + 0, + 0, + 493, + 494, + 7, + 2, + 0, + 0, + 494, + 38, + 1, + 0, + 0, + 0, + 495, + 496, + 5, + 39, + 0, + 0, + 496, + 497, + 3, + 35, + 17, + 0, + 497, + 498, + 5, + 45, + 0, + 0, + 498, + 499, + 3, + 37, + 18, + 0, + 499, + 500, + 5, + 45, + 0, + 0, + 500, + 501, + 3, + 37, + 18, + 0, + 501, + 502, + 5, + 84, + 0, + 0, + 502, + 503, + 3, + 37, + 18, + 0, + 503, + 504, + 5, + 58, + 0, + 0, + 504, + 505, + 3, + 37, + 18, + 0, + 505, + 506, + 5, + 58, + 0, + 0, + 506, + 513, + 3, + 37, + 18, + 0, + 507, + 509, + 5, + 46, + 0, + 0, + 508, + 510, + 7, + 2, + 0, + 0, + 509, + 508, + 1, + 0, + 0, + 0, + 510, + 511, + 1, + 0, + 0, + 0, + 511, + 509, + 1, + 0, + 0, + 0, + 511, + 512, + 1, + 0, + 0, + 0, + 512, + 514, + 1, + 0, + 0, + 0, + 513, + 507, + 1, + 0, + 0, + 0, + 513, + 514, + 1, + 0, + 0, + 0, + 514, + 515, + 1, + 0, + 0, + 0, + 515, + 516, + 7, + 1, + 0, + 0, + 516, + 517, + 3, + 37, + 18, + 0, + 517, + 518, + 5, + 58, + 0, + 0, + 518, + 519, + 3, + 37, + 18, + 0, + 519, + 520, + 5, + 39, + 0, + 0, + 520, + 40, + 1, + 0, + 0, + 0, + 521, + 522, + 5, + 39, + 0, + 0, + 522, + 523, + 3, + 35, + 17, + 0, + 523, + 524, + 5, + 45, + 0, + 0, + 524, + 525, + 3, + 37, + 18, + 0, + 525, + 526, + 5, + 45, + 0, + 0, + 526, + 527, + 3, + 37, + 18, + 0, + 527, + 528, + 5, + 84, + 0, + 0, + 528, + 529, + 3, + 37, + 18, + 0, + 529, + 530, + 5, + 58, + 0, + 0, + 530, + 531, + 3, + 37, + 18, + 0, + 531, + 532, + 5, + 58, + 0, + 0, + 532, + 539, + 3, + 37, + 18, + 0, + 533, + 535, + 5, + 46, + 0, + 0, + 534, + 536, + 7, + 2, + 0, + 0, + 535, + 534, + 1, + 0, + 0, + 0, + 536, + 537, + 1, + 0, + 0, + 0, + 537, + 535, + 1, + 0, + 0, + 0, + 537, + 538, + 1, + 0, + 0, + 0, + 538, + 540, + 1, + 0, + 0, + 0, + 539, + 533, + 1, + 0, + 0, + 0, + 539, + 540, + 1, + 0, + 0, + 0, + 540, + 541, + 1, + 0, + 0, + 0, + 541, + 542, + 5, + 39, + 0, + 0, + 542, + 42, + 1, + 0, + 0, + 0, + 543, + 544, + 5, + 39, + 0, + 0, + 544, + 545, + 3, + 37, + 18, + 0, + 545, + 546, + 5, + 58, + 0, + 0, + 546, + 547, + 3, + 37, + 18, + 0, + 547, + 548, + 5, + 58, + 0, + 0, + 548, + 555, + 3, + 37, + 18, + 0, + 549, + 551, + 5, + 46, + 0, + 0, + 550, + 552, + 7, + 2, + 0, + 0, + 551, + 550, + 1, + 0, + 0, + 0, + 552, + 553, + 1, + 0, + 0, + 0, + 553, + 551, + 1, + 0, + 0, + 0, + 553, + 554, + 1, + 0, + 0, + 0, + 554, + 556, + 1, + 0, + 0, + 0, + 555, + 549, + 1, + 0, + 0, + 0, + 555, + 556, + 1, + 0, + 0, + 0, + 556, + 557, + 1, + 0, + 0, + 0, + 557, + 558, + 5, + 39, + 0, + 0, + 558, + 44, + 1, + 0, + 0, + 0, + 559, + 560, + 5, + 39, + 0, + 0, + 560, + 561, + 3, + 35, + 17, + 0, + 561, + 562, + 5, + 45, + 0, + 0, + 562, + 563, + 3, + 37, + 18, + 0, + 563, + 564, + 5, + 45, + 0, + 0, + 564, + 565, + 3, + 37, + 18, + 0, + 565, + 566, + 5, + 39, + 0, + 0, + 566, + 46, + 1, + 0, + 0, + 0, + 567, + 568, + 5, + 80, + 0, + 0, + 568, + 48, + 1, + 0, + 0, + 0, + 569, + 570, + 5, + 84, + 0, + 0, + 570, + 50, + 1, + 0, + 0, + 0, + 571, + 572, + 5, + 89, + 0, + 0, + 572, + 52, + 1, + 0, + 0, + 0, + 573, + 574, + 5, + 77, + 0, + 0, + 574, + 54, + 1, + 0, + 0, + 0, + 575, + 576, + 5, + 68, + 0, + 0, + 576, + 56, + 1, + 0, + 0, + 0, + 577, + 578, + 5, + 72, + 0, + 0, + 578, + 58, + 1, + 0, + 0, + 0, + 579, + 580, + 5, + 83, + 0, + 0, + 580, + 60, + 1, + 0, + 0, + 0, + 581, + 582, + 5, + 70, + 0, + 0, + 582, + 62, + 1, + 0, + 0, + 0, + 583, + 584, + 5, + 39, + 0, + 0, + 584, + 585, + 3, + 47, + 23, + 0, + 585, + 586, + 3, + 27, + 13, + 0, + 586, + 590, + 3, + 51, + 25, + 0, + 587, + 588, + 3, + 27, + 13, + 0, + 588, + 589, + 3, + 53, + 26, + 0, + 589, + 591, + 1, + 0, + 0, + 0, + 590, + 587, + 1, + 0, + 0, + 0, + 590, + 591, + 1, + 0, + 0, + 0, + 591, + 592, + 1, + 0, + 0, + 0, + 592, + 593, + 5, + 39, + 0, + 0, + 593, + 601, + 1, + 0, + 0, + 0, + 594, + 595, + 5, + 39, + 0, + 0, + 595, + 596, + 3, + 47, + 23, + 0, + 596, + 597, + 3, + 27, + 13, + 0, + 597, + 598, + 3, + 53, + 26, + 0, + 598, + 599, + 5, + 39, + 0, + 0, + 599, + 601, + 1, + 0, + 0, + 0, + 600, + 583, + 1, + 0, + 0, + 0, + 600, + 594, + 1, + 0, + 0, + 0, + 601, + 64, + 1, + 0, + 0, + 0, + 602, + 603, + 5, + 39, + 0, + 0, + 603, + 604, + 3, + 47, + 23, + 0, + 604, + 605, + 3, + 27, + 13, + 0, + 605, + 609, + 3, + 55, + 27, + 0, + 606, + 607, + 3, + 49, + 24, + 0, + 607, + 608, + 3, + 67, + 33, + 0, + 608, + 610, + 1, + 0, + 0, + 0, + 609, + 606, + 1, + 0, + 0, + 0, + 609, + 610, + 1, + 0, + 0, + 0, + 610, + 611, + 1, + 0, + 0, + 0, + 611, + 612, + 5, + 39, + 0, + 0, + 612, + 620, + 1, + 0, + 0, + 0, + 613, + 614, + 5, + 39, + 0, + 0, + 614, + 615, + 3, + 47, + 23, + 0, + 615, + 616, + 3, + 49, + 24, + 0, + 616, + 617, + 3, + 67, + 33, + 0, + 617, + 618, + 5, + 39, + 0, + 0, + 618, + 620, + 1, + 0, + 0, + 0, + 619, + 602, + 1, + 0, + 0, + 0, + 619, + 613, + 1, + 0, + 0, + 0, + 620, + 66, + 1, + 0, + 0, + 0, + 621, + 622, + 3, + 27, + 13, + 0, + 622, + 626, + 3, + 57, + 28, + 0, + 623, + 624, + 3, + 27, + 13, + 0, + 624, + 625, + 3, + 53, + 26, + 0, + 625, + 627, + 1, + 0, + 0, + 0, + 626, + 623, + 1, + 0, + 0, + 0, + 626, + 627, + 1, + 0, + 0, + 0, + 627, + 631, + 1, + 0, + 0, + 0, + 628, + 629, + 3, + 27, + 13, + 0, + 629, + 630, + 3, + 59, + 29, + 0, + 630, + 632, + 1, + 0, + 0, + 0, + 631, + 628, + 1, + 0, + 0, + 0, + 631, + 632, + 1, + 0, + 0, + 0, + 632, + 636, + 1, + 0, + 0, + 0, + 633, + 634, + 3, + 27, + 13, + 0, + 634, + 635, + 3, + 61, + 30, + 0, + 635, + 637, + 1, + 0, + 0, + 0, + 636, + 633, + 1, + 0, + 0, + 0, + 636, + 637, + 1, + 0, + 0, + 0, + 637, + 661, + 1, + 0, + 0, + 0, + 638, + 639, + 3, + 27, + 13, + 0, + 639, + 643, + 3, + 53, + 26, + 0, + 640, + 641, + 3, + 27, + 13, + 0, + 641, + 642, + 3, + 59, + 29, + 0, + 642, + 644, + 1, + 0, + 0, + 0, + 643, + 640, + 1, + 0, + 0, + 0, + 643, + 644, + 1, + 0, + 0, + 0, + 644, + 648, + 1, + 0, + 0, + 0, + 645, + 646, + 3, + 27, + 13, + 0, + 646, + 647, + 3, + 61, + 30, + 0, + 647, + 649, + 1, + 0, + 0, + 0, + 648, + 645, + 1, + 0, + 0, + 0, + 648, + 649, + 1, + 0, + 0, + 0, + 649, + 661, + 1, + 0, + 0, + 0, + 650, + 651, + 3, + 27, + 13, + 0, + 651, + 655, + 3, + 59, + 29, + 0, + 652, + 653, + 3, + 27, + 13, + 0, + 653, + 654, + 3, + 61, + 30, + 0, + 654, + 656, + 1, + 0, + 0, + 0, + 655, + 652, + 1, + 0, + 0, + 0, + 655, + 656, + 1, + 0, + 0, + 0, + 656, + 661, + 1, + 0, + 0, + 0, + 657, + 658, + 3, + 27, + 13, + 0, + 658, + 659, + 3, + 61, + 30, + 0, + 659, + 661, + 1, + 0, + 0, + 0, + 660, + 621, + 1, + 0, + 0, + 0, + 660, + 638, + 1, + 0, + 0, + 0, + 660, + 650, + 1, + 0, + 0, + 0, + 660, + 657, + 1, + 0, + 0, + 0, + 661, + 68, + 1, + 0, + 0, + 0, + 662, + 663, + 5, + 110, + 0, + 0, + 663, + 664, + 5, + 117, + 0, + 0, + 664, + 665, + 5, + 108, + 0, + 0, + 665, + 666, + 5, + 108, + 0, + 0, + 666, + 70, + 1, + 0, + 0, + 0, + 667, + 675, + 5, + 39, + 0, + 0, + 668, + 669, + 5, + 92, + 0, + 0, + 669, + 674, + 9, + 0, + 0, + 0, + 670, + 671, + 5, + 39, + 0, + 0, + 671, + 674, + 5, + 39, + 0, + 0, + 672, + 674, + 8, + 4, + 0, + 0, + 673, + 668, + 1, + 0, + 0, + 0, + 673, + 670, + 1, + 0, + 0, + 0, + 673, + 672, + 1, + 0, + 0, + 0, + 674, + 677, + 1, + 0, + 0, + 0, + 675, + 673, + 1, + 0, + 0, + 0, + 675, + 676, + 1, + 0, + 0, + 0, + 676, + 678, + 1, + 0, + 0, + 0, + 677, + 675, + 1, + 0, + 0, + 0, + 678, + 679, + 5, + 39, + 0, + 0, + 679, + 72, + 1, + 0, + 0, + 0, + 680, + 681, + 5, + 47, + 0, + 0, + 681, + 682, + 5, + 47, + 0, + 0, + 682, + 686, + 1, + 0, + 0, + 0, + 683, + 685, + 8, + 0, + 0, + 0, + 684, + 683, + 1, + 0, + 0, + 0, + 685, + 688, + 1, + 0, + 0, + 0, + 686, + 684, + 1, + 0, + 0, + 0, + 686, + 687, + 1, + 0, + 0, + 0, + 687, + 689, + 1, + 0, + 0, + 0, + 688, + 686, + 1, + 0, + 0, + 0, + 689, + 690, + 6, + 36, + 0, + 0, + 690, + 74, + 1, + 0, + 0, + 0, + 691, + 692, + 5, + 47, + 0, + 0, + 692, + 693, + 5, + 42, + 0, + 0, + 693, + 701, + 1, + 0, + 0, + 0, + 694, + 702, + 8, + 5, + 0, + 0, + 695, + 697, + 5, + 42, + 0, + 0, + 696, + 695, + 1, + 0, + 0, + 0, + 697, + 698, + 1, + 0, + 0, + 0, + 698, + 696, + 1, + 0, + 0, + 0, + 698, + 699, + 1, + 0, + 0, + 0, + 699, + 700, + 1, + 0, + 0, + 0, + 700, + 702, + 8, + 6, + 0, + 0, + 701, + 694, + 1, + 0, + 0, + 0, + 701, + 696, + 1, + 0, + 0, + 0, + 702, + 706, + 1, + 0, + 0, + 0, + 703, + 705, + 5, + 42, + 0, + 0, + 704, + 703, + 1, + 0, + 0, + 0, + 705, + 708, + 1, + 0, + 0, + 0, + 706, + 704, + 1, + 0, + 0, + 0, + 706, + 707, + 1, + 0, + 0, + 0, + 707, + 709, + 1, + 0, + 0, + 0, + 708, + 706, + 1, + 0, + 0, + 0, + 709, + 710, + 5, + 42, + 0, + 0, + 710, + 711, + 5, + 47, + 0, + 0, + 711, + 712, + 1, + 0, + 0, + 0, + 712, + 713, + 6, + 37, + 0, + 0, + 713, + 76, + 1, + 0, + 0, + 0, + 714, + 716, + 7, + 7, + 0, + 0, + 715, + 714, + 1, + 0, + 0, + 0, + 716, + 717, + 1, + 0, + 0, + 0, + 717, + 715, + 1, + 0, + 0, + 0, + 717, + 718, + 1, + 0, + 0, + 0, + 718, + 719, + 1, + 0, + 0, + 0, + 719, + 720, + 6, + 38, + 0, + 0, + 720, + 78, + 1, + 0, + 0, + 0, + 721, + 722, + 7, + 8, + 0, + 0, + 722, + 80, + 1, + 0, + 0, + 0, + 723, + 724, + 7, + 9, + 0, + 0, + 724, + 82, + 1, + 0, + 0, + 0, + 725, + 726, + 7, + 10, + 0, + 0, + 726, + 84, + 1, + 0, + 0, + 0, + 727, + 728, + 7, + 11, + 0, + 0, + 728, + 86, + 1, + 0, + 0, + 0, + 729, + 730, + 7, + 3, + 0, + 0, + 730, + 88, + 1, + 0, + 0, + 0, + 731, + 732, + 7, + 12, + 0, + 0, + 732, + 90, + 1, + 0, + 0, + 0, + 733, + 734, + 7, + 13, + 0, + 0, + 734, + 92, + 1, + 0, + 0, + 0, + 735, + 736, + 7, + 14, + 0, + 0, + 736, + 94, + 1, + 0, + 0, + 0, + 737, + 738, + 7, + 15, + 0, + 0, + 738, + 96, + 1, + 0, + 0, + 0, + 739, + 740, + 7, + 16, + 0, + 0, + 740, + 98, + 1, + 0, + 0, + 0, + 741, + 742, + 7, + 17, + 0, + 0, + 742, + 100, + 1, + 0, + 0, + 0, + 743, + 744, + 7, + 18, + 0, + 0, + 744, + 102, + 1, + 0, + 0, + 0, + 745, + 746, + 7, + 19, + 0, + 0, + 746, + 104, + 1, + 0, + 0, + 0, + 747, + 748, + 7, + 20, + 0, + 0, + 748, + 106, + 1, + 0, + 0, + 0, + 749, + 750, + 7, + 21, + 0, + 0, + 750, + 108, + 1, + 0, + 0, + 0, + 751, + 752, + 7, + 22, + 0, + 0, + 752, + 110, + 1, + 0, + 0, + 0, + 753, + 754, + 7, + 23, + 0, + 0, + 754, + 112, + 1, + 0, + 0, + 0, + 755, + 756, + 7, + 24, + 0, + 0, + 756, + 114, + 1, + 0, + 0, + 0, + 757, + 758, + 7, + 25, + 0, + 0, + 758, + 116, + 1, + 0, + 0, + 0, + 759, + 760, + 7, + 26, + 0, + 0, + 760, + 118, + 1, + 0, + 0, + 0, + 761, + 762, + 7, + 27, + 0, + 0, + 762, + 120, + 1, + 0, + 0, + 0, + 763, + 764, + 7, + 28, + 0, + 0, + 764, + 122, + 1, + 0, + 0, + 0, + 765, + 766, + 7, + 29, + 0, + 0, + 766, + 124, + 1, + 0, + 0, + 0, + 767, + 768, + 7, + 30, + 0, + 0, + 768, + 126, + 1, + 0, + 0, + 0, + 769, + 770, + 7, + 31, + 0, + 0, + 770, + 128, + 1, + 0, + 0, + 0, + 771, + 772, + 7, + 32, + 0, + 0, + 772, + 130, + 1, + 0, + 0, + 0, + 773, + 774, + 7, + 2, + 0, + 0, + 774, + 132, + 1, + 0, + 0, + 0, + 775, + 784, + 5, + 48, + 0, + 0, + 776, + 780, + 7, + 33, + 0, + 0, + 777, + 779, + 7, + 2, + 0, + 0, + 778, + 777, + 1, + 0, + 0, + 0, + 779, + 782, + 1, + 0, + 0, + 0, + 780, + 778, + 1, + 0, + 0, + 0, + 780, + 781, + 1, + 0, + 0, + 0, + 781, + 784, + 1, + 0, + 0, + 0, + 782, + 780, + 1, + 0, + 0, + 0, + 783, + 775, + 1, + 0, + 0, + 0, + 783, + 776, + 1, + 0, + 0, + 0, + 784, + 134, + 1, + 0, + 0, + 0, + 785, + 786, + 3, + 95, + 47, + 0, + 786, + 787, + 3, + 89, + 44, + 0, + 787, + 136, + 1, + 0, + 0, + 0, + 788, + 789, + 3, + 117, + 58, + 0, + 789, + 790, + 3, + 93, + 46, + 0, + 790, + 791, + 3, + 87, + 43, + 0, + 791, + 792, + 3, + 105, + 52, + 0, + 792, + 138, + 1, + 0, + 0, + 0, + 793, + 794, + 3, + 87, + 43, + 0, + 794, + 795, + 3, + 101, + 50, + 0, + 795, + 796, + 3, + 115, + 57, + 0, + 796, + 797, + 3, + 87, + 43, + 0, + 797, + 140, + 1, + 0, + 0, + 0, + 798, + 799, + 3, + 81, + 40, + 0, + 799, + 800, + 3, + 107, + 53, + 0, + 800, + 801, + 3, + 107, + 53, + 0, + 801, + 802, + 3, + 101, + 50, + 0, + 802, + 803, + 3, + 87, + 43, + 0, + 803, + 804, + 3, + 79, + 39, + 0, + 804, + 805, + 3, + 105, + 52, + 0, + 805, + 142, + 1, + 0, + 0, + 0, + 806, + 807, + 3, + 95, + 47, + 0, + 807, + 808, + 5, + 56, + 0, + 0, + 808, + 144, + 1, + 0, + 0, + 0, + 809, + 810, + 3, + 95, + 47, + 0, + 810, + 811, + 5, + 49, + 0, + 0, + 811, + 812, + 5, + 54, + 0, + 0, + 812, + 146, + 1, + 0, + 0, + 0, + 813, + 814, + 3, + 95, + 47, + 0, + 814, + 815, + 5, + 51, + 0, + 0, + 815, + 816, + 5, + 50, + 0, + 0, + 816, + 148, + 1, + 0, + 0, + 0, + 817, + 818, + 3, + 95, + 47, + 0, + 818, + 819, + 5, + 54, + 0, + 0, + 819, + 820, + 5, + 52, + 0, + 0, + 820, + 150, + 1, + 0, + 0, + 0, + 821, + 822, + 3, + 89, + 44, + 0, + 822, + 823, + 3, + 109, + 54, + 0, + 823, + 824, + 5, + 51, + 0, + 0, + 824, + 825, + 5, + 50, + 0, + 0, + 825, + 152, + 1, + 0, + 0, + 0, + 826, + 827, + 3, + 89, + 44, + 0, + 827, + 828, + 3, + 109, + 54, + 0, + 828, + 829, + 5, + 54, + 0, + 0, + 829, + 830, + 5, + 52, + 0, + 0, + 830, + 154, + 1, + 0, + 0, + 0, + 831, + 832, + 3, + 115, + 57, + 0, + 832, + 833, + 3, + 117, + 58, + 0, + 833, + 834, + 3, + 113, + 56, + 0, + 834, + 835, + 3, + 95, + 47, + 0, + 835, + 836, + 3, + 105, + 52, + 0, + 836, + 837, + 3, + 91, + 45, + 0, + 837, + 156, + 1, + 0, + 0, + 0, + 838, + 839, + 3, + 81, + 40, + 0, + 839, + 840, + 3, + 95, + 47, + 0, + 840, + 841, + 3, + 105, + 52, + 0, + 841, + 842, + 3, + 79, + 39, + 0, + 842, + 843, + 3, + 113, + 56, + 0, + 843, + 844, + 3, + 127, + 63, + 0, + 844, + 158, + 1, + 0, + 0, + 0, + 845, + 846, + 3, + 117, + 58, + 0, + 846, + 847, + 3, + 95, + 47, + 0, + 847, + 848, + 3, + 103, + 51, + 0, + 848, + 849, + 3, + 87, + 43, + 0, + 849, + 850, + 3, + 115, + 57, + 0, + 850, + 851, + 3, + 117, + 58, + 0, + 851, + 852, + 3, + 79, + 39, + 0, + 852, + 853, + 3, + 103, + 51, + 0, + 853, + 854, + 3, + 109, + 54, + 0, + 854, + 160, + 1, + 0, + 0, + 0, + 855, + 856, + 3, + 117, + 58, + 0, + 856, + 857, + 3, + 95, + 47, + 0, + 857, + 858, + 3, + 103, + 51, + 0, + 858, + 859, + 3, + 87, + 43, + 0, + 859, + 860, + 3, + 115, + 57, + 0, + 860, + 861, + 3, + 117, + 58, + 0, + 861, + 862, + 3, + 79, + 39, + 0, + 862, + 863, + 3, + 103, + 51, + 0, + 863, + 864, + 3, + 109, + 54, + 0, + 864, + 865, + 5, + 95, + 0, + 0, + 865, + 866, + 3, + 117, + 58, + 0, + 866, + 867, + 3, + 129, + 64, + 0, + 867, + 162, + 1, + 0, + 0, + 0, + 868, + 869, + 3, + 85, + 42, + 0, + 869, + 870, + 3, + 79, + 39, + 0, + 870, + 871, + 3, + 117, + 58, + 0, + 871, + 872, + 3, + 87, + 43, + 0, + 872, + 164, + 1, + 0, + 0, + 0, + 873, + 874, + 3, + 117, + 58, + 0, + 874, + 875, + 3, + 95, + 47, + 0, + 875, + 876, + 3, + 103, + 51, + 0, + 876, + 877, + 3, + 87, + 43, + 0, + 877, + 166, + 1, + 0, + 0, + 0, + 878, + 879, + 3, + 95, + 47, + 0, + 879, + 880, + 3, + 105, + 52, + 0, + 880, + 881, + 3, + 117, + 58, + 0, + 881, + 882, + 3, + 87, + 43, + 0, + 882, + 883, + 3, + 113, + 56, + 0, + 883, + 884, + 3, + 121, + 60, + 0, + 884, + 885, + 3, + 79, + 39, + 0, + 885, + 886, + 3, + 101, + 50, + 0, + 886, + 887, + 5, + 95, + 0, + 0, + 887, + 888, + 3, + 127, + 63, + 0, + 888, + 889, + 3, + 87, + 43, + 0, + 889, + 890, + 3, + 79, + 39, + 0, + 890, + 891, + 3, + 113, + 56, + 0, + 891, + 168, + 1, + 0, + 0, + 0, + 892, + 893, + 3, + 95, + 47, + 0, + 893, + 894, + 3, + 105, + 52, + 0, + 894, + 895, + 3, + 117, + 58, + 0, + 895, + 896, + 3, + 87, + 43, + 0, + 896, + 897, + 3, + 113, + 56, + 0, + 897, + 898, + 3, + 121, + 60, + 0, + 898, + 899, + 3, + 79, + 39, + 0, + 899, + 900, + 3, + 101, + 50, + 0, + 900, + 901, + 5, + 95, + 0, + 0, + 901, + 902, + 3, + 85, + 42, + 0, + 902, + 903, + 3, + 79, + 39, + 0, + 903, + 904, + 3, + 127, + 63, + 0, + 904, + 170, + 1, + 0, + 0, + 0, + 905, + 906, + 3, + 119, + 59, + 0, + 906, + 907, + 3, + 119, + 59, + 0, + 907, + 908, + 3, + 95, + 47, + 0, + 908, + 909, + 3, + 85, + 42, + 0, + 909, + 172, + 1, + 0, + 0, + 0, + 910, + 911, + 3, + 85, + 42, + 0, + 911, + 912, + 3, + 87, + 43, + 0, + 912, + 913, + 3, + 83, + 41, + 0, + 913, + 914, + 3, + 95, + 47, + 0, + 914, + 915, + 3, + 103, + 51, + 0, + 915, + 916, + 3, + 79, + 39, + 0, + 916, + 917, + 3, + 101, + 50, + 0, + 917, + 174, + 1, + 0, + 0, + 0, + 918, + 919, + 3, + 109, + 54, + 0, + 919, + 920, + 3, + 113, + 56, + 0, + 920, + 921, + 3, + 87, + 43, + 0, + 921, + 922, + 3, + 83, + 41, + 0, + 922, + 923, + 3, + 95, + 47, + 0, + 923, + 924, + 3, + 115, + 57, + 0, + 924, + 925, + 3, + 95, + 47, + 0, + 925, + 926, + 3, + 107, + 53, + 0, + 926, + 927, + 3, + 105, + 52, + 0, + 927, + 928, + 5, + 95, + 0, + 0, + 928, + 929, + 3, + 117, + 58, + 0, + 929, + 930, + 3, + 95, + 47, + 0, + 930, + 931, + 3, + 103, + 51, + 0, + 931, + 932, + 3, + 87, + 43, + 0, + 932, + 933, + 3, + 115, + 57, + 0, + 933, + 934, + 3, + 117, + 58, + 0, + 934, + 935, + 3, + 79, + 39, + 0, + 935, + 936, + 3, + 103, + 51, + 0, + 936, + 937, + 3, + 109, + 54, + 0, + 937, + 176, + 1, + 0, + 0, + 0, + 938, + 939, + 3, + 109, + 54, + 0, + 939, + 940, + 3, + 113, + 56, + 0, + 940, + 941, + 3, + 87, + 43, + 0, + 941, + 942, + 3, + 83, + 41, + 0, + 942, + 943, + 3, + 95, + 47, + 0, + 943, + 944, + 3, + 115, + 57, + 0, + 944, + 945, + 3, + 95, + 47, + 0, + 945, + 946, + 3, + 107, + 53, + 0, + 946, + 947, + 3, + 105, + 52, + 0, + 947, + 948, + 5, + 95, + 0, + 0, + 948, + 949, + 3, + 117, + 58, + 0, + 949, + 950, + 3, + 95, + 47, + 0, + 950, + 951, + 3, + 103, + 51, + 0, + 951, + 952, + 3, + 87, + 43, + 0, + 952, + 953, + 3, + 115, + 57, + 0, + 953, + 954, + 3, + 117, + 58, + 0, + 954, + 955, + 3, + 79, + 39, + 0, + 955, + 956, + 3, + 103, + 51, + 0, + 956, + 957, + 3, + 109, + 54, + 0, + 957, + 958, + 5, + 95, + 0, + 0, + 958, + 959, + 3, + 117, + 58, + 0, + 959, + 960, + 3, + 129, + 64, + 0, + 960, + 178, + 1, + 0, + 0, + 0, + 961, + 962, + 3, + 89, + 44, + 0, + 962, + 963, + 3, + 95, + 47, + 0, + 963, + 964, + 3, + 125, + 62, + 0, + 964, + 965, + 3, + 87, + 43, + 0, + 965, + 966, + 3, + 85, + 42, + 0, + 966, + 967, + 3, + 83, + 41, + 0, + 967, + 968, + 3, + 93, + 46, + 0, + 968, + 969, + 3, + 79, + 39, + 0, + 969, + 970, + 3, + 113, + 56, + 0, + 970, + 180, + 1, + 0, + 0, + 0, + 971, + 972, + 3, + 121, + 60, + 0, + 972, + 973, + 3, + 79, + 39, + 0, + 973, + 974, + 3, + 113, + 56, + 0, + 974, + 975, + 3, + 83, + 41, + 0, + 975, + 976, + 3, + 93, + 46, + 0, + 976, + 977, + 3, + 79, + 39, + 0, + 977, + 978, + 3, + 113, + 56, + 0, + 978, + 182, + 1, + 0, + 0, + 0, + 979, + 980, + 3, + 89, + 44, + 0, + 980, + 981, + 3, + 95, + 47, + 0, + 981, + 982, + 3, + 125, + 62, + 0, + 982, + 983, + 3, + 87, + 43, + 0, + 983, + 984, + 3, + 85, + 42, + 0, + 984, + 985, + 3, + 81, + 40, + 0, + 985, + 986, + 3, + 95, + 47, + 0, + 986, + 987, + 3, + 105, + 52, + 0, + 987, + 988, + 3, + 79, + 39, + 0, + 988, + 989, + 3, + 113, + 56, + 0, + 989, + 990, + 3, + 127, + 63, + 0, + 990, + 184, + 1, + 0, + 0, + 0, + 991, + 992, + 3, + 115, + 57, + 0, + 992, + 993, + 3, + 117, + 58, + 0, + 993, + 994, + 3, + 113, + 56, + 0, + 994, + 995, + 3, + 119, + 59, + 0, + 995, + 996, + 3, + 83, + 41, + 0, + 996, + 997, + 3, + 117, + 58, + 0, + 997, + 186, + 1, + 0, + 0, + 0, + 998, + 999, + 3, + 105, + 52, + 0, + 999, + 1000, + 3, + 115, + 57, + 0, + 1000, + 1001, + 3, + 117, + 58, + 0, + 1001, + 1002, + 3, + 113, + 56, + 0, + 1002, + 1003, + 3, + 119, + 59, + 0, + 1003, + 1004, + 3, + 83, + 41, + 0, + 1004, + 1005, + 3, + 117, + 58, + 0, + 1005, + 188, + 1, + 0, + 0, + 0, + 1006, + 1007, + 3, + 101, + 50, + 0, + 1007, + 1008, + 3, + 95, + 47, + 0, + 1008, + 1009, + 3, + 115, + 57, + 0, + 1009, + 1010, + 3, + 117, + 58, + 0, + 1010, + 190, + 1, + 0, + 0, + 0, + 1011, + 1012, + 3, + 103, + 51, + 0, + 1012, + 1013, + 3, + 79, + 39, + 0, + 1013, + 1014, + 3, + 109, + 54, + 0, + 1014, + 192, + 1, + 0, + 0, + 0, + 1015, + 1016, + 3, + 79, + 39, + 0, + 1016, + 1017, + 3, + 105, + 52, + 0, + 1017, + 1018, + 3, + 127, + 63, + 0, + 1018, + 194, + 1, + 0, + 0, + 0, + 1019, + 1020, + 3, + 119, + 59, + 0, + 1020, + 1021, + 5, + 33, + 0, + 0, + 1021, + 196, + 1, + 0, + 0, + 0, + 1022, + 1023, + 3, + 91, + 45, + 0, + 1023, + 1024, + 3, + 87, + 43, + 0, + 1024, + 1025, + 3, + 107, + 53, + 0, + 1025, + 1026, + 3, + 103, + 51, + 0, + 1026, + 1027, + 3, + 87, + 43, + 0, + 1027, + 1028, + 3, + 117, + 58, + 0, + 1028, + 1029, + 3, + 113, + 56, + 0, + 1029, + 1030, + 3, + 127, + 63, + 0, + 1030, + 198, + 1, + 0, + 0, + 0, + 1031, + 1032, + 3, + 81, + 40, + 0, + 1032, + 1033, + 3, + 107, + 53, + 0, + 1033, + 1034, + 3, + 107, + 53, + 0, + 1034, + 1035, + 3, + 101, + 50, + 0, + 1035, + 200, + 1, + 0, + 0, + 0, + 1036, + 1037, + 3, + 115, + 57, + 0, + 1037, + 1038, + 3, + 117, + 58, + 0, + 1038, + 1039, + 3, + 113, + 56, + 0, + 1039, + 202, + 1, + 0, + 0, + 0, + 1040, + 1041, + 3, + 121, + 60, + 0, + 1041, + 1042, + 3, + 81, + 40, + 0, + 1042, + 1043, + 3, + 95, + 47, + 0, + 1043, + 1044, + 3, + 105, + 52, + 0, + 1044, + 204, + 1, + 0, + 0, + 0, + 1045, + 1046, + 3, + 117, + 58, + 0, + 1046, + 1047, + 3, + 115, + 57, + 0, + 1047, + 206, + 1, + 0, + 0, + 0, + 1048, + 1049, + 3, + 117, + 58, + 0, + 1049, + 1050, + 3, + 115, + 57, + 0, + 1050, + 1051, + 3, + 117, + 58, + 0, + 1051, + 1052, + 3, + 129, + 64, + 0, + 1052, + 208, + 1, + 0, + 0, + 0, + 1053, + 1054, + 3, + 95, + 47, + 0, + 1054, + 1055, + 3, + 127, + 63, + 0, + 1055, + 1056, + 3, + 87, + 43, + 0, + 1056, + 1057, + 3, + 79, + 39, + 0, + 1057, + 1058, + 3, + 113, + 56, + 0, + 1058, + 210, + 1, + 0, + 0, + 0, + 1059, + 1060, + 3, + 95, + 47, + 0, + 1060, + 1061, + 3, + 85, + 42, + 0, + 1061, + 1062, + 3, + 79, + 39, + 0, + 1062, + 1063, + 3, + 127, + 63, + 0, + 1063, + 212, + 1, + 0, + 0, + 0, + 1064, + 1065, + 3, + 85, + 42, + 0, + 1065, + 1066, + 3, + 87, + 43, + 0, + 1066, + 1067, + 3, + 83, + 41, + 0, + 1067, + 214, + 1, + 0, + 0, + 0, + 1068, + 1069, + 3, + 109, + 54, + 0, + 1069, + 1070, + 3, + 117, + 58, + 0, + 1070, + 1071, + 3, + 115, + 57, + 0, + 1071, + 216, + 1, + 0, + 0, + 0, + 1072, + 1073, + 3, + 109, + 54, + 0, + 1073, + 1074, + 3, + 117, + 58, + 0, + 1074, + 1075, + 3, + 115, + 57, + 0, + 1075, + 1076, + 3, + 117, + 58, + 0, + 1076, + 1077, + 3, + 129, + 64, + 0, + 1077, + 218, + 1, + 0, + 0, + 0, + 1078, + 1079, + 3, + 89, + 44, + 0, + 1079, + 1080, + 3, + 83, + 41, + 0, + 1080, + 1081, + 3, + 93, + 46, + 0, + 1081, + 1082, + 3, + 79, + 39, + 0, + 1082, + 1083, + 3, + 113, + 56, + 0, + 1083, + 220, + 1, + 0, + 0, + 0, + 1084, + 1085, + 3, + 121, + 60, + 0, + 1085, + 1086, + 3, + 83, + 41, + 0, + 1086, + 1087, + 3, + 93, + 46, + 0, + 1087, + 1088, + 3, + 79, + 39, + 0, + 1088, + 1089, + 3, + 113, + 56, + 0, + 1089, + 222, + 1, + 0, + 0, + 0, + 1090, + 1091, + 3, + 89, + 44, + 0, + 1091, + 1092, + 3, + 81, + 40, + 0, + 1092, + 1093, + 3, + 95, + 47, + 0, + 1093, + 1094, + 3, + 105, + 52, + 0, + 1094, + 224, + 1, + 0, + 0, + 0, + 1095, + 1096, + 5, + 58, + 0, + 0, + 1096, + 1097, + 5, + 58, + 0, + 0, + 1097, + 226, + 1, + 0, + 0, + 0, + 1098, + 1102, + 7, + 34, + 0, + 0, + 1099, + 1101, + 7, + 35, + 0, + 0, + 1100, + 1099, + 1, + 0, + 0, + 0, + 1101, + 1104, + 1, + 0, + 0, + 0, + 1102, + 1100, + 1, + 0, + 0, + 0, + 1102, + 1103, + 1, + 0, + 0, + 0, + 1103, + 228, + 1, + 0, + 0, + 0, + 1104, + 1102, + 1, + 0, + 0, + 0, + 1105, + 1106, + 5, + 60, + 0, + 0, + 1106, + 230, + 1, + 0, + 0, + 0, + 1107, + 1108, + 5, + 62, + 0, + 0, + 1108, + 232, + 1, + 0, + 0, + 0, + 1109, + 1110, + 5, + 40, + 0, + 0, + 1110, + 234, + 1, + 0, + 0, + 0, + 1111, + 1112, + 5, + 41, + 0, + 0, + 1112, + 236, + 1, + 0, + 0, + 0, + 1113, + 1114, + 5, + 91, + 0, + 0, + 1114, + 238, + 1, + 0, + 0, + 0, + 1115, + 1116, + 5, + 93, + 0, + 0, + 1116, + 240, + 1, + 0, + 0, + 0, + 1117, + 1118, + 5, + 44, + 0, + 0, + 1118, + 242, + 1, + 0, + 0, + 0, + 1119, + 1120, + 5, + 61, + 0, + 0, + 1120, + 244, + 1, + 0, + 0, + 0, + 1121, + 1122, + 5, + 58, + 0, + 0, + 1122, + 246, + 1, + 0, + 0, + 0, + 1123, + 1124, + 5, + 63, + 0, + 0, + 1124, + 248, + 1, + 0, + 0, + 0, + 1125, + 1126, + 5, + 35, + 0, + 0, + 1126, + 250, + 1, + 0, + 0, + 0, + 1127, + 1128, + 5, + 46, + 0, + 0, + 1128, + 252, + 1, + 0, + 0, + 0, + 48, + 0, + 284, + 290, + 292, + 323, + 327, + 410, + 415, + 420, + 426, + 428, + 431, + 436, + 442, + 445, + 449, + 454, + 456, + 459, + 474, + 485, + 511, + 513, + 537, + 539, + 553, + 555, + 590, + 600, + 609, + 619, + 626, + 631, + 636, + 643, + 648, + 655, + 660, + 673, + 675, + 686, + 698, + 701, + 706, + 717, + 780, + 783, + 1102, + 1, + 0, + 1, + 0, ] + class FuncTestCaseLexer(Lexer): atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] SUBSTRAIT_SCALAR_TEST = 1 FORMAT_VERSION = 2 @@ -529,71 +9872,282 @@ class FuncTestCaseLexer(Lexer): HASH = 94 DOT = 95 - channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] - modeNames = [ "DEFAULT_MODE" ] + modeNames = ["DEFAULT_MODE"] - literalNames = [ "", - "'### SUBSTRAIT_SCALAR_TEST:'", "'### SUBSTRAIT_INCLUDE:'", - "''", "''", "'overlfow'", "'rounding'", - "'ERROR'", "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", - "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", "'null'", - "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", - "':'", "'?'", "'#'", "'.'" ] + literalNames = [ + "", + "'### SUBSTRAIT_SCALAR_TEST:'", + "'### SUBSTRAIT_INCLUDE:'", + "''", + "''", + "'overlfow'", + "'rounding'", + "'ERROR'", + "'SATURATE'", + "'SILENT'", + "'TIE_TO_EVEN'", + "'NAN'", + "'P'", + "'T'", + "'Y'", + "'M'", + "'D'", + "'H'", + "'S'", + "'F'", + "'null'", + "'::'", + "'<'", + "'>'", + "'('", + "')'", + "'['", + "']'", + "','", + "'='", + "':'", + "'?'", + "'#'", + "'.'", + ] - symbolicNames = [ "", - "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", - "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", "OVERFLOW", - "ROUNDING", "ERROR", "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", - "INTEGER_LITERAL", "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", - "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", - "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", - "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", "FRACTIONAL_SECOND_SUFFIX", - "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", "NULL_LITERAL", - "STRING_LITERAL", "LineComment", "BlockComment", "Whitespace", - "If", "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", - "FP32", "FP64", "String", "Binary", "Timestamp", "Timestamp_TZ", - "Date", "Time", "Interval_Year", "Interval_Day", "UUID", "Decimal", - "Precision_Timestamp", "Precision_Timestamp_TZ", "FixedChar", - "VarChar", "FixedBinary", "Struct", "NStruct", "List", "Map", - "ANY", "UserDefined", "Geometry", "Bool", "Str", "VBin", "Ts", - "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", "FChar", "VChar", - "FBin", "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", - "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", - "QMARK", "HASH", "DOT" ] + symbolicNames = [ + "", + "SUBSTRAIT_SCALAR_TEST", + "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", + "ERROR_RESULT", + "UNDEFINED_RESULT", + "OVERFLOW", + "ROUNDING", + "ERROR", + "SATURATE", + "SILENT", + "TIE_TO_EVEN", + "NAN", + "INTEGER_LITERAL", + "DECIMAL_LITERAL", + "FLOAT_LITERAL", + "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", + "TIMESTAMP_LITERAL", + "TIME_LITERAL", + "DATE_LITERAL", + "PERIOD_PREFIX", + "TIME_PREFIX", + "YEAR_SUFFIX", + "M_SUFFIX", + "DAY_SUFFIX", + "HOUR_SUFFIX", + "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", + "NULL_LITERAL", + "STRING_LITERAL", + "LineComment", + "BlockComment", + "Whitespace", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "Timestamp_TZ", + "Date", + "Time", + "Interval_Year", + "Interval_Day", + "UUID", + "Decimal", + "Precision_Timestamp", + "Precision_Timestamp_TZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Geometry", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] - ruleNames = [ "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", "SUBSTRAIT_INCLUDE", - "DESCRIPTION_LINE", "ERROR_RESULT", "UNDEFINED_RESULT", - "OVERFLOW", "ROUNDING", "ERROR", "SATURATE", "SILENT", - "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", "DECIMAL_LITERAL", - "FLOAT_LITERAL", "BOOLEAN_LITERAL", "FourDigits", "TwoDigits", - "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", - "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", - "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", - "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", "INTERVAL_DAY_LITERAL", - "TIME_INTERVAL", "NULL_LITERAL", "STRING_LITERAL", "LineComment", - "BlockComment", "Whitespace", "A", "B", "C", "D", "E", - "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", - "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "DIGIT", - "INTEGER", "If", "Then", "Else", "Boolean", "I8", "I16", - "I32", "I64", "FP32", "FP64", "String", "Binary", "Timestamp", - "Timestamp_TZ", "Date", "Time", "Interval_Year", "Interval_Day", - "UUID", "Decimal", "Precision_Timestamp", "Precision_Timestamp_TZ", - "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", - "List", "Map", "ANY", "UserDefined", "Geometry", "Bool", - "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", - "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", - "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", "OPAREN", "CPAREN", - "OBRACKET", "CBRACKET", "COMMA", "EQ", "COLON", "QMARK", - "HASH", "DOT" ] + ruleNames = [ + "SUBSTRAIT_SCALAR_TEST", + "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", + "ERROR_RESULT", + "UNDEFINED_RESULT", + "OVERFLOW", + "ROUNDING", + "ERROR", + "SATURATE", + "SILENT", + "TIE_TO_EVEN", + "NAN", + "INTEGER_LITERAL", + "DECIMAL_LITERAL", + "FLOAT_LITERAL", + "BOOLEAN_LITERAL", + "FourDigits", + "TwoDigits", + "TIMESTAMP_TZ_LITERAL", + "TIMESTAMP_LITERAL", + "TIME_LITERAL", + "DATE_LITERAL", + "PERIOD_PREFIX", + "TIME_PREFIX", + "YEAR_SUFFIX", + "M_SUFFIX", + "DAY_SUFFIX", + "HOUR_SUFFIX", + "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", + "TIME_INTERVAL", + "NULL_LITERAL", + "STRING_LITERAL", + "LineComment", + "BlockComment", + "Whitespace", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "DIGIT", + "INTEGER", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "Timestamp_TZ", + "Date", + "Time", + "Interval_Year", + "Interval_Day", + "UUID", + "Decimal", + "Precision_Timestamp", + "Precision_Timestamp_TZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Geometry", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] grammarFileName = "FuncTestCaseLexer.g4" - def __init__(self, input=None, output:TextIO = sys.stdout): + def __init__(self, input=None, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") - self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._interp = LexerATNSimulator( + self, self.atn, self.decisionsToDFA, PredictionContextCache() + ) self._actions = None self._predicates = None - - diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py index 3ae45d866..f5d17b2ff 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParser.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -3,210 +3,3630 @@ from antlr4 import * from io import StringIO import sys + if sys.version_info[1] > 5: - from typing import TextIO + from typing import TextIO else: - from typing.io import TextIO + from typing.io import TextIO + def serializedATN(): return [ - 4,1,95,395,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7, - 6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13, - 2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20, - 7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26, - 2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33, - 7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39, - 2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,1,0,1,0,4,0,93, - 8,0,11,0,12,0,94,1,0,1,0,1,1,1,1,1,1,1,2,1,2,1,2,1,3,1,3,1,3,1,3, - 5,3,109,8,3,10,3,12,3,112,9,3,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,1, - 5,1,5,3,5,124,8,5,1,5,1,5,1,5,1,6,1,6,4,6,131,8,6,11,6,12,6,132, - 1,7,1,7,1,7,5,7,138,8,7,10,7,12,7,141,9,7,1,8,1,8,3,8,145,8,8,1, - 9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,1,9,3, - 9,163,8,9,1,10,1,10,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13, - 1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,15,1,16,1,16, - 1,16,1,16,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,19,1,19,1,19, - 1,19,1,20,1,20,1,20,1,20,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22, - 1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,26, - 1,26,1,26,1,26,1,27,1,27,1,27,1,27,1,27,1,27,3,27,237,8,27,1,27, - 1,27,1,27,3,27,242,8,27,1,28,1,28,1,28,1,28,1,28,1,28,3,28,250,8, - 28,1,28,1,28,1,28,3,28,255,8,28,1,29,1,29,1,29,1,29,3,29,261,8,29, - 1,29,1,29,3,29,265,8,29,1,29,1,29,3,29,269,8,29,1,29,1,29,1,29,1, - 29,3,29,275,8,29,1,29,1,29,3,29,279,8,29,1,29,1,29,1,29,1,29,3,29, - 285,8,29,1,29,1,29,3,29,289,8,29,1,30,1,30,3,30,293,8,30,1,31,1, - 31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1, - 31,1,31,1,31,1,31,3,31,313,8,31,1,32,1,32,3,32,317,8,32,1,32,1,32, - 1,32,1,32,1,33,1,33,3,33,325,8,33,1,33,1,33,1,33,1,33,1,34,1,34, - 3,34,333,8,34,1,34,1,34,1,34,1,34,1,35,1,35,3,35,341,8,35,1,35,1, - 35,1,35,1,35,1,35,1,35,3,35,349,8,35,1,36,1,36,3,36,353,8,36,1,36, - 1,36,1,36,1,36,1,37,1,37,3,37,361,8,37,1,37,1,37,1,37,1,37,1,38, - 1,38,1,38,1,38,1,38,1,38,3,38,373,8,38,1,39,1,39,1,40,1,40,1,41, - 1,41,1,41,1,41,1,42,1,42,1,43,1,43,1,44,1,44,1,44,5,44,390,8,44, - 10,44,12,44,393,9,44,1,44,0,0,45,0,2,4,6,8,10,12,14,16,18,20,22, - 24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66, - 68,70,72,74,76,78,80,82,84,86,88,0,4,1,0,14,16,1,0,5,6,2,0,7,8,83, - 83,1,0,9,13,413,0,90,1,0,0,0,2,98,1,0,0,0,4,101,1,0,0,0,6,104,1, - 0,0,0,8,113,1,0,0,0,10,115,1,0,0,0,12,128,1,0,0,0,14,134,1,0,0,0, - 16,144,1,0,0,0,18,162,1,0,0,0,20,164,1,0,0,0,22,166,1,0,0,0,24,170, - 1,0,0,0,26,174,1,0,0,0,28,178,1,0,0,0,30,182,1,0,0,0,32,186,1,0, - 0,0,34,190,1,0,0,0,36,194,1,0,0,0,38,198,1,0,0,0,40,202,1,0,0,0, - 42,206,1,0,0,0,44,210,1,0,0,0,46,214,1,0,0,0,48,218,1,0,0,0,50,222, - 1,0,0,0,52,226,1,0,0,0,54,241,1,0,0,0,56,254,1,0,0,0,58,288,1,0, - 0,0,60,292,1,0,0,0,62,312,1,0,0,0,64,314,1,0,0,0,66,322,1,0,0,0, - 68,330,1,0,0,0,70,338,1,0,0,0,72,350,1,0,0,0,74,358,1,0,0,0,76,372, - 1,0,0,0,78,374,1,0,0,0,80,376,1,0,0,0,82,378,1,0,0,0,84,382,1,0, - 0,0,86,384,1,0,0,0,88,386,1,0,0,0,90,92,3,2,1,0,91,93,3,12,6,0,92, - 91,1,0,0,0,93,94,1,0,0,0,94,92,1,0,0,0,94,95,1,0,0,0,95,96,1,0,0, - 0,96,97,5,0,0,1,97,1,1,0,0,0,98,99,3,4,2,0,99,100,3,6,3,0,100,3, - 1,0,0,0,101,102,5,1,0,0,102,103,5,2,0,0,103,5,1,0,0,0,104,105,5, - 3,0,0,105,110,5,33,0,0,106,107,5,90,0,0,107,109,5,33,0,0,108,106, - 1,0,0,0,109,112,1,0,0,0,110,108,1,0,0,0,110,111,1,0,0,0,111,7,1, - 0,0,0,112,110,1,0,0,0,113,114,5,4,0,0,114,9,1,0,0,0,115,116,5,83, - 0,0,116,117,5,86,0,0,117,118,3,14,7,0,118,123,5,87,0,0,119,120,5, - 88,0,0,120,121,3,88,44,0,121,122,5,89,0,0,122,124,1,0,0,0,123,119, - 1,0,0,0,123,124,1,0,0,0,124,125,1,0,0,0,125,126,5,91,0,0,126,127, - 3,16,8,0,127,11,1,0,0,0,128,130,3,8,4,0,129,131,3,10,5,0,130,129, - 1,0,0,0,131,132,1,0,0,0,132,130,1,0,0,0,132,133,1,0,0,0,133,13,1, - 0,0,0,134,139,3,18,9,0,135,136,5,90,0,0,136,138,3,18,9,0,137,135, - 1,0,0,0,138,141,1,0,0,0,139,137,1,0,0,0,139,140,1,0,0,0,140,15,1, - 0,0,0,141,139,1,0,0,0,142,145,3,18,9,0,143,145,3,80,40,0,144,142, - 1,0,0,0,144,143,1,0,0,0,145,17,1,0,0,0,146,163,3,22,11,0,147,163, - 3,24,12,0,148,163,3,26,13,0,149,163,3,28,14,0,150,163,3,30,15,0, - 151,163,3,32,16,0,152,163,3,34,17,0,153,163,3,38,19,0,154,163,3, - 40,20,0,155,163,3,36,18,0,156,163,3,42,21,0,157,163,3,44,22,0,158, - 163,3,46,23,0,159,163,3,48,24,0,160,163,3,50,25,0,161,163,3,52,26, - 0,162,146,1,0,0,0,162,147,1,0,0,0,162,148,1,0,0,0,162,149,1,0,0, - 0,162,150,1,0,0,0,162,151,1,0,0,0,162,152,1,0,0,0,162,153,1,0,0, - 0,162,154,1,0,0,0,162,155,1,0,0,0,162,156,1,0,0,0,162,157,1,0,0, - 0,162,158,1,0,0,0,162,159,1,0,0,0,162,160,1,0,0,0,162,161,1,0,0, - 0,163,19,1,0,0,0,164,165,7,0,0,0,165,21,1,0,0,0,166,167,5,32,0,0, - 167,168,5,82,0,0,168,169,3,60,30,0,169,23,1,0,0,0,170,171,5,14,0, - 0,171,172,5,82,0,0,172,173,5,41,0,0,173,25,1,0,0,0,174,175,5,14, - 0,0,175,176,5,82,0,0,176,177,5,42,0,0,177,27,1,0,0,0,178,179,5,14, - 0,0,179,180,5,82,0,0,180,181,5,43,0,0,181,29,1,0,0,0,182,183,5,14, - 0,0,183,184,5,82,0,0,184,185,5,44,0,0,185,31,1,0,0,0,186,187,3,20, - 10,0,187,188,5,82,0,0,188,189,5,45,0,0,189,33,1,0,0,0,190,191,3, - 20,10,0,191,192,5,82,0,0,192,193,5,46,0,0,193,35,1,0,0,0,194,195, - 3,20,10,0,195,196,5,82,0,0,196,197,3,70,35,0,197,37,1,0,0,0,198, - 199,5,17,0,0,199,200,5,82,0,0,200,201,5,69,0,0,201,39,1,0,0,0,202, - 203,5,33,0,0,203,204,5,82,0,0,204,205,5,70,0,0,205,41,1,0,0,0,206, - 207,5,21,0,0,207,208,5,82,0,0,208,209,5,51,0,0,209,43,1,0,0,0,210, - 211,5,20,0,0,211,212,5,82,0,0,212,213,5,52,0,0,213,45,1,0,0,0,214, - 215,5,19,0,0,215,216,5,82,0,0,216,217,5,72,0,0,217,47,1,0,0,0,218, - 219,5,18,0,0,219,220,5,82,0,0,220,221,5,73,0,0,221,49,1,0,0,0,222, - 223,5,30,0,0,223,224,5,82,0,0,224,225,5,74,0,0,225,51,1,0,0,0,226, - 227,5,31,0,0,227,228,5,82,0,0,228,229,5,75,0,0,229,53,1,0,0,0,230, - 231,5,22,0,0,231,232,5,14,0,0,232,233,5,24,0,0,233,236,1,0,0,0,234, - 235,5,14,0,0,235,237,5,25,0,0,236,234,1,0,0,0,236,237,1,0,0,0,237, - 242,1,0,0,0,238,239,5,22,0,0,239,240,5,14,0,0,240,242,5,25,0,0,241, - 230,1,0,0,0,241,238,1,0,0,0,242,55,1,0,0,0,243,244,5,22,0,0,244, - 245,5,14,0,0,245,246,5,26,0,0,246,249,1,0,0,0,247,248,5,23,0,0,248, - 250,3,58,29,0,249,247,1,0,0,0,249,250,1,0,0,0,250,255,1,0,0,0,251, - 252,5,22,0,0,252,253,5,23,0,0,253,255,3,58,29,0,254,243,1,0,0,0, - 254,251,1,0,0,0,255,57,1,0,0,0,256,257,5,14,0,0,257,260,5,27,0,0, - 258,259,5,14,0,0,259,261,5,25,0,0,260,258,1,0,0,0,260,261,1,0,0, - 0,261,264,1,0,0,0,262,263,5,14,0,0,263,265,5,28,0,0,264,262,1,0, - 0,0,264,265,1,0,0,0,265,268,1,0,0,0,266,267,5,14,0,0,267,269,5,29, - 0,0,268,266,1,0,0,0,268,269,1,0,0,0,269,289,1,0,0,0,270,271,5,14, - 0,0,271,274,5,25,0,0,272,273,5,14,0,0,273,275,5,28,0,0,274,272,1, - 0,0,0,274,275,1,0,0,0,275,278,1,0,0,0,276,277,5,14,0,0,277,279,5, - 29,0,0,278,276,1,0,0,0,278,279,1,0,0,0,279,289,1,0,0,0,280,281,5, - 14,0,0,281,284,5,28,0,0,282,283,5,14,0,0,283,285,5,29,0,0,284,282, - 1,0,0,0,284,285,1,0,0,0,285,289,1,0,0,0,286,287,5,14,0,0,287,289, - 5,29,0,0,288,256,1,0,0,0,288,270,1,0,0,0,288,280,1,0,0,0,288,286, - 1,0,0,0,289,59,1,0,0,0,290,293,3,62,31,0,291,293,3,76,38,0,292,290, - 1,0,0,0,292,291,1,0,0,0,293,61,1,0,0,0,294,313,5,69,0,0,295,313, - 5,41,0,0,296,313,5,42,0,0,297,313,5,43,0,0,298,313,5,44,0,0,299, - 313,5,45,0,0,300,313,5,46,0,0,301,313,5,70,0,0,302,313,5,48,0,0, - 303,313,5,72,0,0,304,313,5,73,0,0,305,313,5,51,0,0,306,313,5,52, - 0,0,307,313,5,75,0,0,308,313,5,74,0,0,309,313,5,55,0,0,310,311,5, - 67,0,0,311,313,5,83,0,0,312,294,1,0,0,0,312,295,1,0,0,0,312,296, - 1,0,0,0,312,297,1,0,0,0,312,298,1,0,0,0,312,299,1,0,0,0,312,300, - 1,0,0,0,312,301,1,0,0,0,312,302,1,0,0,0,312,303,1,0,0,0,312,304, - 1,0,0,0,312,305,1,0,0,0,312,306,1,0,0,0,312,307,1,0,0,0,312,308, - 1,0,0,0,312,309,1,0,0,0,312,310,1,0,0,0,313,63,1,0,0,0,314,316,5, - 79,0,0,315,317,5,93,0,0,316,315,1,0,0,0,316,317,1,0,0,0,317,318, - 1,0,0,0,318,319,5,84,0,0,319,320,3,78,39,0,320,321,5,85,0,0,321, - 65,1,0,0,0,322,324,5,80,0,0,323,325,5,93,0,0,324,323,1,0,0,0,324, - 325,1,0,0,0,325,326,1,0,0,0,326,327,5,84,0,0,327,328,3,78,39,0,328, - 329,5,85,0,0,329,67,1,0,0,0,330,332,5,81,0,0,331,333,5,93,0,0,332, - 331,1,0,0,0,332,333,1,0,0,0,333,334,1,0,0,0,334,335,5,84,0,0,335, - 336,3,78,39,0,336,337,5,85,0,0,337,69,1,0,0,0,338,340,5,76,0,0,339, - 341,5,93,0,0,340,339,1,0,0,0,340,341,1,0,0,0,341,348,1,0,0,0,342, - 343,5,84,0,0,343,344,3,78,39,0,344,345,5,90,0,0,345,346,3,78,39, - 0,346,347,5,85,0,0,347,349,1,0,0,0,348,342,1,0,0,0,348,349,1,0,0, - 0,349,71,1,0,0,0,350,352,5,77,0,0,351,353,5,93,0,0,352,351,1,0,0, - 0,352,353,1,0,0,0,353,354,1,0,0,0,354,355,5,84,0,0,355,356,3,78, - 39,0,356,357,5,85,0,0,357,73,1,0,0,0,358,360,5,78,0,0,359,361,5, - 93,0,0,360,359,1,0,0,0,360,361,1,0,0,0,361,362,1,0,0,0,362,363,5, - 84,0,0,363,364,3,78,39,0,364,365,5,85,0,0,365,75,1,0,0,0,366,373, - 3,64,32,0,367,373,3,66,33,0,368,373,3,68,34,0,369,373,3,70,35,0, - 370,373,3,72,36,0,371,373,3,74,37,0,372,366,1,0,0,0,372,367,1,0, - 0,0,372,368,1,0,0,0,372,369,1,0,0,0,372,370,1,0,0,0,372,371,1,0, - 0,0,373,77,1,0,0,0,374,375,5,14,0,0,375,79,1,0,0,0,376,377,7,1,0, - 0,377,81,1,0,0,0,378,379,3,84,42,0,379,380,5,92,0,0,380,381,3,86, - 43,0,381,83,1,0,0,0,382,383,7,2,0,0,383,85,1,0,0,0,384,385,7,3,0, - 0,385,87,1,0,0,0,386,391,3,82,41,0,387,388,5,90,0,0,388,390,3,82, - 41,0,389,387,1,0,0,0,390,393,1,0,0,0,391,389,1,0,0,0,391,392,1,0, - 0,0,392,89,1,0,0,0,393,391,1,0,0,0,29,94,110,123,132,139,144,162, - 236,241,249,254,260,264,268,274,278,284,288,292,312,316,324,332, - 340,348,352,360,372,391 + 4, + 1, + 95, + 395, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 1, + 0, + 1, + 0, + 4, + 0, + 93, + 8, + 0, + 11, + 0, + 12, + 0, + 94, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 3, + 1, + 3, + 5, + 3, + 109, + 8, + 3, + 10, + 3, + 12, + 3, + 112, + 9, + 3, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 3, + 5, + 124, + 8, + 5, + 1, + 5, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 4, + 6, + 131, + 8, + 6, + 11, + 6, + 12, + 6, + 132, + 1, + 7, + 1, + 7, + 1, + 7, + 5, + 7, + 138, + 8, + 7, + 10, + 7, + 12, + 7, + 141, + 9, + 7, + 1, + 8, + 1, + 8, + 3, + 8, + 145, + 8, + 8, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 1, + 9, + 3, + 9, + 163, + 8, + 9, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 12, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 13, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 14, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 15, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 16, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 3, + 27, + 237, + 8, + 27, + 1, + 27, + 1, + 27, + 1, + 27, + 3, + 27, + 242, + 8, + 27, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 3, + 28, + 250, + 8, + 28, + 1, + 28, + 1, + 28, + 1, + 28, + 3, + 28, + 255, + 8, + 28, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 261, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 265, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 269, + 8, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 275, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 279, + 8, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 285, + 8, + 29, + 1, + 29, + 1, + 29, + 3, + 29, + 289, + 8, + 29, + 1, + 30, + 1, + 30, + 3, + 30, + 293, + 8, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 31, + 3, + 31, + 313, + 8, + 31, + 1, + 32, + 1, + 32, + 3, + 32, + 317, + 8, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 33, + 1, + 33, + 3, + 33, + 325, + 8, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 34, + 1, + 34, + 3, + 34, + 333, + 8, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 3, + 35, + 341, + 8, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 35, + 3, + 35, + 349, + 8, + 35, + 1, + 36, + 1, + 36, + 3, + 36, + 353, + 8, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 3, + 37, + 361, + 8, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 3, + 38, + 373, + 8, + 38, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 44, + 5, + 44, + 390, + 8, + 44, + 10, + 44, + 12, + 44, + 393, + 9, + 44, + 1, + 44, + 0, + 0, + 45, + 0, + 2, + 4, + 6, + 8, + 10, + 12, + 14, + 16, + 18, + 20, + 22, + 24, + 26, + 28, + 30, + 32, + 34, + 36, + 38, + 40, + 42, + 44, + 46, + 48, + 50, + 52, + 54, + 56, + 58, + 60, + 62, + 64, + 66, + 68, + 70, + 72, + 74, + 76, + 78, + 80, + 82, + 84, + 86, + 88, + 0, + 4, + 1, + 0, + 14, + 16, + 1, + 0, + 5, + 6, + 2, + 0, + 7, + 8, + 83, + 83, + 1, + 0, + 9, + 13, + 413, + 0, + 90, + 1, + 0, + 0, + 0, + 2, + 98, + 1, + 0, + 0, + 0, + 4, + 101, + 1, + 0, + 0, + 0, + 6, + 104, + 1, + 0, + 0, + 0, + 8, + 113, + 1, + 0, + 0, + 0, + 10, + 115, + 1, + 0, + 0, + 0, + 12, + 128, + 1, + 0, + 0, + 0, + 14, + 134, + 1, + 0, + 0, + 0, + 16, + 144, + 1, + 0, + 0, + 0, + 18, + 162, + 1, + 0, + 0, + 0, + 20, + 164, + 1, + 0, + 0, + 0, + 22, + 166, + 1, + 0, + 0, + 0, + 24, + 170, + 1, + 0, + 0, + 0, + 26, + 174, + 1, + 0, + 0, + 0, + 28, + 178, + 1, + 0, + 0, + 0, + 30, + 182, + 1, + 0, + 0, + 0, + 32, + 186, + 1, + 0, + 0, + 0, + 34, + 190, + 1, + 0, + 0, + 0, + 36, + 194, + 1, + 0, + 0, + 0, + 38, + 198, + 1, + 0, + 0, + 0, + 40, + 202, + 1, + 0, + 0, + 0, + 42, + 206, + 1, + 0, + 0, + 0, + 44, + 210, + 1, + 0, + 0, + 0, + 46, + 214, + 1, + 0, + 0, + 0, + 48, + 218, + 1, + 0, + 0, + 0, + 50, + 222, + 1, + 0, + 0, + 0, + 52, + 226, + 1, + 0, + 0, + 0, + 54, + 241, + 1, + 0, + 0, + 0, + 56, + 254, + 1, + 0, + 0, + 0, + 58, + 288, + 1, + 0, + 0, + 0, + 60, + 292, + 1, + 0, + 0, + 0, + 62, + 312, + 1, + 0, + 0, + 0, + 64, + 314, + 1, + 0, + 0, + 0, + 66, + 322, + 1, + 0, + 0, + 0, + 68, + 330, + 1, + 0, + 0, + 0, + 70, + 338, + 1, + 0, + 0, + 0, + 72, + 350, + 1, + 0, + 0, + 0, + 74, + 358, + 1, + 0, + 0, + 0, + 76, + 372, + 1, + 0, + 0, + 0, + 78, + 374, + 1, + 0, + 0, + 0, + 80, + 376, + 1, + 0, + 0, + 0, + 82, + 378, + 1, + 0, + 0, + 0, + 84, + 382, + 1, + 0, + 0, + 0, + 86, + 384, + 1, + 0, + 0, + 0, + 88, + 386, + 1, + 0, + 0, + 0, + 90, + 92, + 3, + 2, + 1, + 0, + 91, + 93, + 3, + 12, + 6, + 0, + 92, + 91, + 1, + 0, + 0, + 0, + 93, + 94, + 1, + 0, + 0, + 0, + 94, + 92, + 1, + 0, + 0, + 0, + 94, + 95, + 1, + 0, + 0, + 0, + 95, + 96, + 1, + 0, + 0, + 0, + 96, + 97, + 5, + 0, + 0, + 1, + 97, + 1, + 1, + 0, + 0, + 0, + 98, + 99, + 3, + 4, + 2, + 0, + 99, + 100, + 3, + 6, + 3, + 0, + 100, + 3, + 1, + 0, + 0, + 0, + 101, + 102, + 5, + 1, + 0, + 0, + 102, + 103, + 5, + 2, + 0, + 0, + 103, + 5, + 1, + 0, + 0, + 0, + 104, + 105, + 5, + 3, + 0, + 0, + 105, + 110, + 5, + 33, + 0, + 0, + 106, + 107, + 5, + 90, + 0, + 0, + 107, + 109, + 5, + 33, + 0, + 0, + 108, + 106, + 1, + 0, + 0, + 0, + 109, + 112, + 1, + 0, + 0, + 0, + 110, + 108, + 1, + 0, + 0, + 0, + 110, + 111, + 1, + 0, + 0, + 0, + 111, + 7, + 1, + 0, + 0, + 0, + 112, + 110, + 1, + 0, + 0, + 0, + 113, + 114, + 5, + 4, + 0, + 0, + 114, + 9, + 1, + 0, + 0, + 0, + 115, + 116, + 5, + 83, + 0, + 0, + 116, + 117, + 5, + 86, + 0, + 0, + 117, + 118, + 3, + 14, + 7, + 0, + 118, + 123, + 5, + 87, + 0, + 0, + 119, + 120, + 5, + 88, + 0, + 0, + 120, + 121, + 3, + 88, + 44, + 0, + 121, + 122, + 5, + 89, + 0, + 0, + 122, + 124, + 1, + 0, + 0, + 0, + 123, + 119, + 1, + 0, + 0, + 0, + 123, + 124, + 1, + 0, + 0, + 0, + 124, + 125, + 1, + 0, + 0, + 0, + 125, + 126, + 5, + 91, + 0, + 0, + 126, + 127, + 3, + 16, + 8, + 0, + 127, + 11, + 1, + 0, + 0, + 0, + 128, + 130, + 3, + 8, + 4, + 0, + 129, + 131, + 3, + 10, + 5, + 0, + 130, + 129, + 1, + 0, + 0, + 0, + 131, + 132, + 1, + 0, + 0, + 0, + 132, + 130, + 1, + 0, + 0, + 0, + 132, + 133, + 1, + 0, + 0, + 0, + 133, + 13, + 1, + 0, + 0, + 0, + 134, + 139, + 3, + 18, + 9, + 0, + 135, + 136, + 5, + 90, + 0, + 0, + 136, + 138, + 3, + 18, + 9, + 0, + 137, + 135, + 1, + 0, + 0, + 0, + 138, + 141, + 1, + 0, + 0, + 0, + 139, + 137, + 1, + 0, + 0, + 0, + 139, + 140, + 1, + 0, + 0, + 0, + 140, + 15, + 1, + 0, + 0, + 0, + 141, + 139, + 1, + 0, + 0, + 0, + 142, + 145, + 3, + 18, + 9, + 0, + 143, + 145, + 3, + 80, + 40, + 0, + 144, + 142, + 1, + 0, + 0, + 0, + 144, + 143, + 1, + 0, + 0, + 0, + 145, + 17, + 1, + 0, + 0, + 0, + 146, + 163, + 3, + 22, + 11, + 0, + 147, + 163, + 3, + 24, + 12, + 0, + 148, + 163, + 3, + 26, + 13, + 0, + 149, + 163, + 3, + 28, + 14, + 0, + 150, + 163, + 3, + 30, + 15, + 0, + 151, + 163, + 3, + 32, + 16, + 0, + 152, + 163, + 3, + 34, + 17, + 0, + 153, + 163, + 3, + 38, + 19, + 0, + 154, + 163, + 3, + 40, + 20, + 0, + 155, + 163, + 3, + 36, + 18, + 0, + 156, + 163, + 3, + 42, + 21, + 0, + 157, + 163, + 3, + 44, + 22, + 0, + 158, + 163, + 3, + 46, + 23, + 0, + 159, + 163, + 3, + 48, + 24, + 0, + 160, + 163, + 3, + 50, + 25, + 0, + 161, + 163, + 3, + 52, + 26, + 0, + 162, + 146, + 1, + 0, + 0, + 0, + 162, + 147, + 1, + 0, + 0, + 0, + 162, + 148, + 1, + 0, + 0, + 0, + 162, + 149, + 1, + 0, + 0, + 0, + 162, + 150, + 1, + 0, + 0, + 0, + 162, + 151, + 1, + 0, + 0, + 0, + 162, + 152, + 1, + 0, + 0, + 0, + 162, + 153, + 1, + 0, + 0, + 0, + 162, + 154, + 1, + 0, + 0, + 0, + 162, + 155, + 1, + 0, + 0, + 0, + 162, + 156, + 1, + 0, + 0, + 0, + 162, + 157, + 1, + 0, + 0, + 0, + 162, + 158, + 1, + 0, + 0, + 0, + 162, + 159, + 1, + 0, + 0, + 0, + 162, + 160, + 1, + 0, + 0, + 0, + 162, + 161, + 1, + 0, + 0, + 0, + 163, + 19, + 1, + 0, + 0, + 0, + 164, + 165, + 7, + 0, + 0, + 0, + 165, + 21, + 1, + 0, + 0, + 0, + 166, + 167, + 5, + 32, + 0, + 0, + 167, + 168, + 5, + 82, + 0, + 0, + 168, + 169, + 3, + 60, + 30, + 0, + 169, + 23, + 1, + 0, + 0, + 0, + 170, + 171, + 5, + 14, + 0, + 0, + 171, + 172, + 5, + 82, + 0, + 0, + 172, + 173, + 5, + 41, + 0, + 0, + 173, + 25, + 1, + 0, + 0, + 0, + 174, + 175, + 5, + 14, + 0, + 0, + 175, + 176, + 5, + 82, + 0, + 0, + 176, + 177, + 5, + 42, + 0, + 0, + 177, + 27, + 1, + 0, + 0, + 0, + 178, + 179, + 5, + 14, + 0, + 0, + 179, + 180, + 5, + 82, + 0, + 0, + 180, + 181, + 5, + 43, + 0, + 0, + 181, + 29, + 1, + 0, + 0, + 0, + 182, + 183, + 5, + 14, + 0, + 0, + 183, + 184, + 5, + 82, + 0, + 0, + 184, + 185, + 5, + 44, + 0, + 0, + 185, + 31, + 1, + 0, + 0, + 0, + 186, + 187, + 3, + 20, + 10, + 0, + 187, + 188, + 5, + 82, + 0, + 0, + 188, + 189, + 5, + 45, + 0, + 0, + 189, + 33, + 1, + 0, + 0, + 0, + 190, + 191, + 3, + 20, + 10, + 0, + 191, + 192, + 5, + 82, + 0, + 0, + 192, + 193, + 5, + 46, + 0, + 0, + 193, + 35, + 1, + 0, + 0, + 0, + 194, + 195, + 3, + 20, + 10, + 0, + 195, + 196, + 5, + 82, + 0, + 0, + 196, + 197, + 3, + 70, + 35, + 0, + 197, + 37, + 1, + 0, + 0, + 0, + 198, + 199, + 5, + 17, + 0, + 0, + 199, + 200, + 5, + 82, + 0, + 0, + 200, + 201, + 5, + 69, + 0, + 0, + 201, + 39, + 1, + 0, + 0, + 0, + 202, + 203, + 5, + 33, + 0, + 0, + 203, + 204, + 5, + 82, + 0, + 0, + 204, + 205, + 5, + 70, + 0, + 0, + 205, + 41, + 1, + 0, + 0, + 0, + 206, + 207, + 5, + 21, + 0, + 0, + 207, + 208, + 5, + 82, + 0, + 0, + 208, + 209, + 5, + 51, + 0, + 0, + 209, + 43, + 1, + 0, + 0, + 0, + 210, + 211, + 5, + 20, + 0, + 0, + 211, + 212, + 5, + 82, + 0, + 0, + 212, + 213, + 5, + 52, + 0, + 0, + 213, + 45, + 1, + 0, + 0, + 0, + 214, + 215, + 5, + 19, + 0, + 0, + 215, + 216, + 5, + 82, + 0, + 0, + 216, + 217, + 5, + 72, + 0, + 0, + 217, + 47, + 1, + 0, + 0, + 0, + 218, + 219, + 5, + 18, + 0, + 0, + 219, + 220, + 5, + 82, + 0, + 0, + 220, + 221, + 5, + 73, + 0, + 0, + 221, + 49, + 1, + 0, + 0, + 0, + 222, + 223, + 5, + 30, + 0, + 0, + 223, + 224, + 5, + 82, + 0, + 0, + 224, + 225, + 5, + 74, + 0, + 0, + 225, + 51, + 1, + 0, + 0, + 0, + 226, + 227, + 5, + 31, + 0, + 0, + 227, + 228, + 5, + 82, + 0, + 0, + 228, + 229, + 5, + 75, + 0, + 0, + 229, + 53, + 1, + 0, + 0, + 0, + 230, + 231, + 5, + 22, + 0, + 0, + 231, + 232, + 5, + 14, + 0, + 0, + 232, + 233, + 5, + 24, + 0, + 0, + 233, + 236, + 1, + 0, + 0, + 0, + 234, + 235, + 5, + 14, + 0, + 0, + 235, + 237, + 5, + 25, + 0, + 0, + 236, + 234, + 1, + 0, + 0, + 0, + 236, + 237, + 1, + 0, + 0, + 0, + 237, + 242, + 1, + 0, + 0, + 0, + 238, + 239, + 5, + 22, + 0, + 0, + 239, + 240, + 5, + 14, + 0, + 0, + 240, + 242, + 5, + 25, + 0, + 0, + 241, + 230, + 1, + 0, + 0, + 0, + 241, + 238, + 1, + 0, + 0, + 0, + 242, + 55, + 1, + 0, + 0, + 0, + 243, + 244, + 5, + 22, + 0, + 0, + 244, + 245, + 5, + 14, + 0, + 0, + 245, + 246, + 5, + 26, + 0, + 0, + 246, + 249, + 1, + 0, + 0, + 0, + 247, + 248, + 5, + 23, + 0, + 0, + 248, + 250, + 3, + 58, + 29, + 0, + 249, + 247, + 1, + 0, + 0, + 0, + 249, + 250, + 1, + 0, + 0, + 0, + 250, + 255, + 1, + 0, + 0, + 0, + 251, + 252, + 5, + 22, + 0, + 0, + 252, + 253, + 5, + 23, + 0, + 0, + 253, + 255, + 3, + 58, + 29, + 0, + 254, + 243, + 1, + 0, + 0, + 0, + 254, + 251, + 1, + 0, + 0, + 0, + 255, + 57, + 1, + 0, + 0, + 0, + 256, + 257, + 5, + 14, + 0, + 0, + 257, + 260, + 5, + 27, + 0, + 0, + 258, + 259, + 5, + 14, + 0, + 0, + 259, + 261, + 5, + 25, + 0, + 0, + 260, + 258, + 1, + 0, + 0, + 0, + 260, + 261, + 1, + 0, + 0, + 0, + 261, + 264, + 1, + 0, + 0, + 0, + 262, + 263, + 5, + 14, + 0, + 0, + 263, + 265, + 5, + 28, + 0, + 0, + 264, + 262, + 1, + 0, + 0, + 0, + 264, + 265, + 1, + 0, + 0, + 0, + 265, + 268, + 1, + 0, + 0, + 0, + 266, + 267, + 5, + 14, + 0, + 0, + 267, + 269, + 5, + 29, + 0, + 0, + 268, + 266, + 1, + 0, + 0, + 0, + 268, + 269, + 1, + 0, + 0, + 0, + 269, + 289, + 1, + 0, + 0, + 0, + 270, + 271, + 5, + 14, + 0, + 0, + 271, + 274, + 5, + 25, + 0, + 0, + 272, + 273, + 5, + 14, + 0, + 0, + 273, + 275, + 5, + 28, + 0, + 0, + 274, + 272, + 1, + 0, + 0, + 0, + 274, + 275, + 1, + 0, + 0, + 0, + 275, + 278, + 1, + 0, + 0, + 0, + 276, + 277, + 5, + 14, + 0, + 0, + 277, + 279, + 5, + 29, + 0, + 0, + 278, + 276, + 1, + 0, + 0, + 0, + 278, + 279, + 1, + 0, + 0, + 0, + 279, + 289, + 1, + 0, + 0, + 0, + 280, + 281, + 5, + 14, + 0, + 0, + 281, + 284, + 5, + 28, + 0, + 0, + 282, + 283, + 5, + 14, + 0, + 0, + 283, + 285, + 5, + 29, + 0, + 0, + 284, + 282, + 1, + 0, + 0, + 0, + 284, + 285, + 1, + 0, + 0, + 0, + 285, + 289, + 1, + 0, + 0, + 0, + 286, + 287, + 5, + 14, + 0, + 0, + 287, + 289, + 5, + 29, + 0, + 0, + 288, + 256, + 1, + 0, + 0, + 0, + 288, + 270, + 1, + 0, + 0, + 0, + 288, + 280, + 1, + 0, + 0, + 0, + 288, + 286, + 1, + 0, + 0, + 0, + 289, + 59, + 1, + 0, + 0, + 0, + 290, + 293, + 3, + 62, + 31, + 0, + 291, + 293, + 3, + 76, + 38, + 0, + 292, + 290, + 1, + 0, + 0, + 0, + 292, + 291, + 1, + 0, + 0, + 0, + 293, + 61, + 1, + 0, + 0, + 0, + 294, + 313, + 5, + 69, + 0, + 0, + 295, + 313, + 5, + 41, + 0, + 0, + 296, + 313, + 5, + 42, + 0, + 0, + 297, + 313, + 5, + 43, + 0, + 0, + 298, + 313, + 5, + 44, + 0, + 0, + 299, + 313, + 5, + 45, + 0, + 0, + 300, + 313, + 5, + 46, + 0, + 0, + 301, + 313, + 5, + 70, + 0, + 0, + 302, + 313, + 5, + 48, + 0, + 0, + 303, + 313, + 5, + 72, + 0, + 0, + 304, + 313, + 5, + 73, + 0, + 0, + 305, + 313, + 5, + 51, + 0, + 0, + 306, + 313, + 5, + 52, + 0, + 0, + 307, + 313, + 5, + 75, + 0, + 0, + 308, + 313, + 5, + 74, + 0, + 0, + 309, + 313, + 5, + 55, + 0, + 0, + 310, + 311, + 5, + 67, + 0, + 0, + 311, + 313, + 5, + 83, + 0, + 0, + 312, + 294, + 1, + 0, + 0, + 0, + 312, + 295, + 1, + 0, + 0, + 0, + 312, + 296, + 1, + 0, + 0, + 0, + 312, + 297, + 1, + 0, + 0, + 0, + 312, + 298, + 1, + 0, + 0, + 0, + 312, + 299, + 1, + 0, + 0, + 0, + 312, + 300, + 1, + 0, + 0, + 0, + 312, + 301, + 1, + 0, + 0, + 0, + 312, + 302, + 1, + 0, + 0, + 0, + 312, + 303, + 1, + 0, + 0, + 0, + 312, + 304, + 1, + 0, + 0, + 0, + 312, + 305, + 1, + 0, + 0, + 0, + 312, + 306, + 1, + 0, + 0, + 0, + 312, + 307, + 1, + 0, + 0, + 0, + 312, + 308, + 1, + 0, + 0, + 0, + 312, + 309, + 1, + 0, + 0, + 0, + 312, + 310, + 1, + 0, + 0, + 0, + 313, + 63, + 1, + 0, + 0, + 0, + 314, + 316, + 5, + 79, + 0, + 0, + 315, + 317, + 5, + 93, + 0, + 0, + 316, + 315, + 1, + 0, + 0, + 0, + 316, + 317, + 1, + 0, + 0, + 0, + 317, + 318, + 1, + 0, + 0, + 0, + 318, + 319, + 5, + 84, + 0, + 0, + 319, + 320, + 3, + 78, + 39, + 0, + 320, + 321, + 5, + 85, + 0, + 0, + 321, + 65, + 1, + 0, + 0, + 0, + 322, + 324, + 5, + 80, + 0, + 0, + 323, + 325, + 5, + 93, + 0, + 0, + 324, + 323, + 1, + 0, + 0, + 0, + 324, + 325, + 1, + 0, + 0, + 0, + 325, + 326, + 1, + 0, + 0, + 0, + 326, + 327, + 5, + 84, + 0, + 0, + 327, + 328, + 3, + 78, + 39, + 0, + 328, + 329, + 5, + 85, + 0, + 0, + 329, + 67, + 1, + 0, + 0, + 0, + 330, + 332, + 5, + 81, + 0, + 0, + 331, + 333, + 5, + 93, + 0, + 0, + 332, + 331, + 1, + 0, + 0, + 0, + 332, + 333, + 1, + 0, + 0, + 0, + 333, + 334, + 1, + 0, + 0, + 0, + 334, + 335, + 5, + 84, + 0, + 0, + 335, + 336, + 3, + 78, + 39, + 0, + 336, + 337, + 5, + 85, + 0, + 0, + 337, + 69, + 1, + 0, + 0, + 0, + 338, + 340, + 5, + 76, + 0, + 0, + 339, + 341, + 5, + 93, + 0, + 0, + 340, + 339, + 1, + 0, + 0, + 0, + 340, + 341, + 1, + 0, + 0, + 0, + 341, + 348, + 1, + 0, + 0, + 0, + 342, + 343, + 5, + 84, + 0, + 0, + 343, + 344, + 3, + 78, + 39, + 0, + 344, + 345, + 5, + 90, + 0, + 0, + 345, + 346, + 3, + 78, + 39, + 0, + 346, + 347, + 5, + 85, + 0, + 0, + 347, + 349, + 1, + 0, + 0, + 0, + 348, + 342, + 1, + 0, + 0, + 0, + 348, + 349, + 1, + 0, + 0, + 0, + 349, + 71, + 1, + 0, + 0, + 0, + 350, + 352, + 5, + 77, + 0, + 0, + 351, + 353, + 5, + 93, + 0, + 0, + 352, + 351, + 1, + 0, + 0, + 0, + 352, + 353, + 1, + 0, + 0, + 0, + 353, + 354, + 1, + 0, + 0, + 0, + 354, + 355, + 5, + 84, + 0, + 0, + 355, + 356, + 3, + 78, + 39, + 0, + 356, + 357, + 5, + 85, + 0, + 0, + 357, + 73, + 1, + 0, + 0, + 0, + 358, + 360, + 5, + 78, + 0, + 0, + 359, + 361, + 5, + 93, + 0, + 0, + 360, + 359, + 1, + 0, + 0, + 0, + 360, + 361, + 1, + 0, + 0, + 0, + 361, + 362, + 1, + 0, + 0, + 0, + 362, + 363, + 5, + 84, + 0, + 0, + 363, + 364, + 3, + 78, + 39, + 0, + 364, + 365, + 5, + 85, + 0, + 0, + 365, + 75, + 1, + 0, + 0, + 0, + 366, + 373, + 3, + 64, + 32, + 0, + 367, + 373, + 3, + 66, + 33, + 0, + 368, + 373, + 3, + 68, + 34, + 0, + 369, + 373, + 3, + 70, + 35, + 0, + 370, + 373, + 3, + 72, + 36, + 0, + 371, + 373, + 3, + 74, + 37, + 0, + 372, + 366, + 1, + 0, + 0, + 0, + 372, + 367, + 1, + 0, + 0, + 0, + 372, + 368, + 1, + 0, + 0, + 0, + 372, + 369, + 1, + 0, + 0, + 0, + 372, + 370, + 1, + 0, + 0, + 0, + 372, + 371, + 1, + 0, + 0, + 0, + 373, + 77, + 1, + 0, + 0, + 0, + 374, + 375, + 5, + 14, + 0, + 0, + 375, + 79, + 1, + 0, + 0, + 0, + 376, + 377, + 7, + 1, + 0, + 0, + 377, + 81, + 1, + 0, + 0, + 0, + 378, + 379, + 3, + 84, + 42, + 0, + 379, + 380, + 5, + 92, + 0, + 0, + 380, + 381, + 3, + 86, + 43, + 0, + 381, + 83, + 1, + 0, + 0, + 0, + 382, + 383, + 7, + 2, + 0, + 0, + 383, + 85, + 1, + 0, + 0, + 0, + 384, + 385, + 7, + 3, + 0, + 0, + 385, + 87, + 1, + 0, + 0, + 0, + 386, + 391, + 3, + 82, + 41, + 0, + 387, + 388, + 5, + 90, + 0, + 0, + 388, + 390, + 3, + 82, + 41, + 0, + 389, + 387, + 1, + 0, + 0, + 0, + 390, + 393, + 1, + 0, + 0, + 0, + 391, + 389, + 1, + 0, + 0, + 0, + 391, + 392, + 1, + 0, + 0, + 0, + 392, + 89, + 1, + 0, + 0, + 0, + 393, + 391, + 1, + 0, + 0, + 0, + 29, + 94, + 110, + 123, + 132, + 139, + 144, + 162, + 236, + 241, + 249, + 254, + 260, + 264, + 268, + 274, + 278, + 284, + 288, + 292, + 312, + 316, + 324, + 332, + 340, + 348, + 352, + 360, + 372, + 391, ] -class FuncTestCaseParser ( Parser ): + +class FuncTestCaseParser(Parser): grammarFileName = "FuncTestCaseParser.g4" atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] sharedContextCache = PredictionContextCache() - literalNames = [ "", "'### SUBSTRAIT_SCALAR_TEST:'", "", - "'### SUBSTRAIT_INCLUDE:'", "", "''", - "''", "'overlfow'", "'rounding'", "'ERROR'", - "'SATURATE'", "'SILENT'", "'TIE_TO_EVEN'", "'NAN'", - "", "", "", "", - "", "", "", "", - "'P'", "'T'", "'Y'", "'M'", "'D'", "'H'", "'S'", "'F'", - "", "", "'null'", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "", - "", "", "", "'::'", "", - "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", - "':'", "'?'", "'#'", "'.'" ] - - symbolicNames = [ "", "SUBSTRAIT_SCALAR_TEST", "FORMAT_VERSION", - "SUBSTRAIT_INCLUDE", "DESCRIPTION_LINE", "ERROR_RESULT", - "UNDEFINED_RESULT", "OVERFLOW", "ROUNDING", "ERROR", - "SATURATE", "SILENT", "TIE_TO_EVEN", "NAN", "INTEGER_LITERAL", - "DECIMAL_LITERAL", "FLOAT_LITERAL", "BOOLEAN_LITERAL", - "TIMESTAMP_TZ_LITERAL", "TIMESTAMP_LITERAL", "TIME_LITERAL", - "DATE_LITERAL", "PERIOD_PREFIX", "TIME_PREFIX", "YEAR_SUFFIX", - "M_SUFFIX", "DAY_SUFFIX", "HOUR_SUFFIX", "SECOND_SUFFIX", - "FRACTIONAL_SECOND_SUFFIX", "INTERVAL_YEAR_LITERAL", - "INTERVAL_DAY_LITERAL", "NULL_LITERAL", "STRING_LITERAL", - "LineComment", "BlockComment", "Whitespace", "If", - "Then", "Else", "Boolean", "I8", "I16", "I32", "I64", - "FP32", "FP64", "String", "Binary", "Timestamp", "Timestamp_TZ", - "Date", "Time", "Interval_Year", "Interval_Day", "UUID", - "Decimal", "Precision_Timestamp", "Precision_Timestamp_TZ", - "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", - "List", "Map", "ANY", "UserDefined", "Geometry", "Bool", - "Str", "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", - "PTs", "PTsTZ", "FChar", "VChar", "FBin", "DOUBLE_COLON", - "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", - "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", - "EQ", "COLON", "QMARK", "HASH", "DOT" ] + literalNames = [ + "", + "'### SUBSTRAIT_SCALAR_TEST:'", + "", + "'### SUBSTRAIT_INCLUDE:'", + "", + "''", + "''", + "'overlfow'", + "'rounding'", + "'ERROR'", + "'SATURATE'", + "'SILENT'", + "'TIE_TO_EVEN'", + "'NAN'", + "", + "", + "", + "", + "", + "", + "", + "", + "'P'", + "'T'", + "'Y'", + "'M'", + "'D'", + "'H'", + "'S'", + "'F'", + "", + "", + "'null'", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "'::'", + "", + "'<'", + "'>'", + "'('", + "')'", + "'['", + "']'", + "','", + "'='", + "':'", + "'?'", + "'#'", + "'.'", + ] + + symbolicNames = [ + "", + "SUBSTRAIT_SCALAR_TEST", + "FORMAT_VERSION", + "SUBSTRAIT_INCLUDE", + "DESCRIPTION_LINE", + "ERROR_RESULT", + "UNDEFINED_RESULT", + "OVERFLOW", + "ROUNDING", + "ERROR", + "SATURATE", + "SILENT", + "TIE_TO_EVEN", + "NAN", + "INTEGER_LITERAL", + "DECIMAL_LITERAL", + "FLOAT_LITERAL", + "BOOLEAN_LITERAL", + "TIMESTAMP_TZ_LITERAL", + "TIMESTAMP_LITERAL", + "TIME_LITERAL", + "DATE_LITERAL", + "PERIOD_PREFIX", + "TIME_PREFIX", + "YEAR_SUFFIX", + "M_SUFFIX", + "DAY_SUFFIX", + "HOUR_SUFFIX", + "SECOND_SUFFIX", + "FRACTIONAL_SECOND_SUFFIX", + "INTERVAL_YEAR_LITERAL", + "INTERVAL_DAY_LITERAL", + "NULL_LITERAL", + "STRING_LITERAL", + "LineComment", + "BlockComment", + "Whitespace", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "Timestamp_TZ", + "Date", + "Time", + "Interval_Year", + "Interval_Day", + "UUID", + "Decimal", + "Precision_Timestamp", + "Precision_Timestamp_TZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Geometry", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] RULE_doc = 0 RULE_header = 1 @@ -254,184 +3674,216 @@ class FuncTestCaseParser ( Parser ): RULE_option_value = 43 RULE_func_options = 44 - ruleNames = [ "doc", "header", "version", "include", "testGroupDescription", - "testCase", "testGroup", "arguments", "result", "argument", - "numericLiteral", "nullArg", "i8Arg", "i16Arg", "i32Arg", - "i64Arg", "fp32Arg", "fp64Arg", "decimalArg", "booleanArg", - "stringArg", "dateArg", "timeArg", "timestampArg", "timestampTzArg", - "intervalYearArg", "intervalDayArg", "intervalYearLiteral", - "intervalDayLiteral", "timeInterval", "datatype", "scalarType", - "fixedCharType", "varCharType", "fixedBinaryType", "decimalType", - "precisionTimestampType", "precisionTimestampTZType", - "parameterizedType", "numericParameter", "substraitError", - "func_option", "option_name", "option_value", "func_options" ] + ruleNames = [ + "doc", + "header", + "version", + "include", + "testGroupDescription", + "testCase", + "testGroup", + "arguments", + "result", + "argument", + "numericLiteral", + "nullArg", + "i8Arg", + "i16Arg", + "i32Arg", + "i64Arg", + "fp32Arg", + "fp64Arg", + "decimalArg", + "booleanArg", + "stringArg", + "dateArg", + "timeArg", + "timestampArg", + "timestampTzArg", + "intervalYearArg", + "intervalDayArg", + "intervalYearLiteral", + "intervalDayLiteral", + "timeInterval", + "datatype", + "scalarType", + "fixedCharType", + "varCharType", + "fixedBinaryType", + "decimalType", + "precisionTimestampType", + "precisionTimestampTZType", + "parameterizedType", + "numericParameter", + "substraitError", + "func_option", + "option_name", + "option_value", + "func_options", + ] EOF = Token.EOF - SUBSTRAIT_SCALAR_TEST=1 - FORMAT_VERSION=2 - SUBSTRAIT_INCLUDE=3 - DESCRIPTION_LINE=4 - ERROR_RESULT=5 - UNDEFINED_RESULT=6 - OVERFLOW=7 - ROUNDING=8 - ERROR=9 - SATURATE=10 - SILENT=11 - TIE_TO_EVEN=12 - NAN=13 - INTEGER_LITERAL=14 - DECIMAL_LITERAL=15 - FLOAT_LITERAL=16 - BOOLEAN_LITERAL=17 - TIMESTAMP_TZ_LITERAL=18 - TIMESTAMP_LITERAL=19 - TIME_LITERAL=20 - DATE_LITERAL=21 - PERIOD_PREFIX=22 - TIME_PREFIX=23 - YEAR_SUFFIX=24 - M_SUFFIX=25 - DAY_SUFFIX=26 - HOUR_SUFFIX=27 - SECOND_SUFFIX=28 - FRACTIONAL_SECOND_SUFFIX=29 - INTERVAL_YEAR_LITERAL=30 - INTERVAL_DAY_LITERAL=31 - NULL_LITERAL=32 - STRING_LITERAL=33 - LineComment=34 - BlockComment=35 - Whitespace=36 - If=37 - Then=38 - Else=39 - Boolean=40 - I8=41 - I16=42 - I32=43 - I64=44 - FP32=45 - FP64=46 - String=47 - Binary=48 - Timestamp=49 - Timestamp_TZ=50 - Date=51 - Time=52 - Interval_Year=53 - Interval_Day=54 - UUID=55 - Decimal=56 - Precision_Timestamp=57 - Precision_Timestamp_TZ=58 - FixedChar=59 - VarChar=60 - FixedBinary=61 - Struct=62 - NStruct=63 - List=64 - Map=65 - ANY=66 - UserDefined=67 - Geometry=68 - Bool=69 - Str=70 - VBin=71 - Ts=72 - TsTZ=73 - IYear=74 - IDay=75 - Dec=76 - PTs=77 - PTsTZ=78 - FChar=79 - VChar=80 - FBin=81 - DOUBLE_COLON=82 - IDENTIFIER=83 - O_ANGLE_BRACKET=84 - C_ANGLE_BRACKET=85 - OPAREN=86 - CPAREN=87 - OBRACKET=88 - CBRACKET=89 - COMMA=90 - EQ=91 - COLON=92 - QMARK=93 - HASH=94 - DOT=95 - - def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + SUBSTRAIT_SCALAR_TEST = 1 + FORMAT_VERSION = 2 + SUBSTRAIT_INCLUDE = 3 + DESCRIPTION_LINE = 4 + ERROR_RESULT = 5 + UNDEFINED_RESULT = 6 + OVERFLOW = 7 + ROUNDING = 8 + ERROR = 9 + SATURATE = 10 + SILENT = 11 + TIE_TO_EVEN = 12 + NAN = 13 + INTEGER_LITERAL = 14 + DECIMAL_LITERAL = 15 + FLOAT_LITERAL = 16 + BOOLEAN_LITERAL = 17 + TIMESTAMP_TZ_LITERAL = 18 + TIMESTAMP_LITERAL = 19 + TIME_LITERAL = 20 + DATE_LITERAL = 21 + PERIOD_PREFIX = 22 + TIME_PREFIX = 23 + YEAR_SUFFIX = 24 + M_SUFFIX = 25 + DAY_SUFFIX = 26 + HOUR_SUFFIX = 27 + SECOND_SUFFIX = 28 + FRACTIONAL_SECOND_SUFFIX = 29 + INTERVAL_YEAR_LITERAL = 30 + INTERVAL_DAY_LITERAL = 31 + NULL_LITERAL = 32 + STRING_LITERAL = 33 + LineComment = 34 + BlockComment = 35 + Whitespace = 36 + If = 37 + Then = 38 + Else = 39 + Boolean = 40 + I8 = 41 + I16 = 42 + I32 = 43 + I64 = 44 + FP32 = 45 + FP64 = 46 + String = 47 + Binary = 48 + Timestamp = 49 + Timestamp_TZ = 50 + Date = 51 + Time = 52 + Interval_Year = 53 + Interval_Day = 54 + UUID = 55 + Decimal = 56 + Precision_Timestamp = 57 + Precision_Timestamp_TZ = 58 + FixedChar = 59 + VarChar = 60 + FixedBinary = 61 + Struct = 62 + NStruct = 63 + List = 64 + Map = 65 + ANY = 66 + UserDefined = 67 + Geometry = 68 + Bool = 69 + Str = 70 + VBin = 71 + Ts = 72 + TsTZ = 73 + IYear = 74 + IDay = 75 + Dec = 76 + PTs = 77 + PTsTZ = 78 + FChar = 79 + VChar = 80 + FBin = 81 + DOUBLE_COLON = 82 + IDENTIFIER = 83 + O_ANGLE_BRACKET = 84 + C_ANGLE_BRACKET = 85 + OPAREN = 86 + CPAREN = 87 + OBRACKET = 88 + CBRACKET = 89 + COMMA = 90 + EQ = 91 + COLON = 92 + QMARK = 93 + HASH = 94 + DOT = 95 + + def __init__(self, input: TokenStream, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") - self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._interp = ParserATNSimulator( + self, self.atn, self.decisionsToDFA, self.sharedContextCache + ) self._predicates = None - - - class DocContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def header(self): - return self.getTypedRuleContext(FuncTestCaseParser.HeaderContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.HeaderContext, 0) def EOF(self): return self.getToken(FuncTestCaseParser.EOF, 0) - def testGroup(self, i:int=None): + def testGroup(self, i: int = None): if i is None: return self.getTypedRuleContexts(FuncTestCaseParser.TestGroupContext) else: - return self.getTypedRuleContext(FuncTestCaseParser.TestGroupContext,i) - + return self.getTypedRuleContext(FuncTestCaseParser.TestGroupContext, i) def getRuleIndex(self): return FuncTestCaseParser.RULE_doc - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDoc" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDoc"): listener.enterDoc(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDoc" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDoc"): listener.exitDoc(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDoc" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDoc"): return visitor.visitDoc(self) else: return visitor.visitChildren(self) - - - def doc(self): localctx = FuncTestCaseParser.DocContext(self, self._ctx, self.state) self.enterRule(localctx, 0, self.RULE_doc) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 90 self.header() - self.state = 92 + self.state = 92 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 91 self.testGroup() - self.state = 94 + self.state = 94 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==4): + if not (_la == 4): break self.state = 96 @@ -444,42 +3896,38 @@ def doc(self): self.exitRule() return localctx - class HeaderContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def version(self): - return self.getTypedRuleContext(FuncTestCaseParser.VersionContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.VersionContext, 0) def include(self): - return self.getTypedRuleContext(FuncTestCaseParser.IncludeContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.IncludeContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_header - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterHeader" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterHeader"): listener.enterHeader(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitHeader" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitHeader"): listener.exitHeader(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitHeader" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitHeader"): return visitor.visitHeader(self) else: return visitor.visitChildren(self) - - - def header(self): localctx = FuncTestCaseParser.HeaderContext(self, self._ctx, self.state) @@ -498,11 +3946,12 @@ def header(self): self.exitRule() return localctx - class VersionContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -515,23 +3964,20 @@ def FORMAT_VERSION(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_version - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVersion" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVersion"): listener.enterVersion(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVersion" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVersion"): listener.exitVersion(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVersion" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVersion"): return visitor.visitVersion(self) else: return visitor.visitChildren(self) - - - def version(self): localctx = FuncTestCaseParser.VersionContext(self, self._ctx, self.state) @@ -550,24 +3996,25 @@ def version(self): self.exitRule() return localctx - class IncludeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def SUBSTRAIT_INCLUDE(self): return self.getToken(FuncTestCaseParser.SUBSTRAIT_INCLUDE, 0) - def STRING_LITERAL(self, i:int=None): + def STRING_LITERAL(self, i: int = None): if i is None: return self.getTokens(FuncTestCaseParser.STRING_LITERAL) else: return self.getToken(FuncTestCaseParser.STRING_LITERAL, i) - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(FuncTestCaseParser.COMMA) else: @@ -576,28 +4023,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return FuncTestCaseParser.RULE_include - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterInclude" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterInclude"): listener.enterInclude(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitInclude" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitInclude"): listener.exitInclude(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitInclude" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitInclude"): return visitor.visitInclude(self) else: return visitor.visitChildren(self) - - - def include(self): localctx = FuncTestCaseParser.IncludeContext(self, self._ctx, self.state) self.enterRule(localctx, 6, self.RULE_include) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 104 @@ -607,7 +4051,7 @@ def include(self): self.state = 110 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==90: + while _la == 90: self.state = 106 self.match(FuncTestCaseParser.COMMA) self.state = 107 @@ -624,11 +4068,12 @@ def include(self): self.exitRule() return localctx - class TestGroupDescriptionContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -638,26 +4083,25 @@ def DESCRIPTION_LINE(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_testGroupDescription - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTestGroupDescription" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestGroupDescription"): listener.enterTestGroupDescription(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTestGroupDescription" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestGroupDescription"): listener.exitTestGroupDescription(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTestGroupDescription" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestGroupDescription"): return visitor.visitTestGroupDescription(self) else: return visitor.visitChildren(self) - - - def testGroupDescription(self): - localctx = FuncTestCaseParser.TestGroupDescriptionContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.TestGroupDescriptionContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 8, self.RULE_testGroupDescription) try: self.enterOuterAlt(localctx, 1) @@ -671,21 +4115,21 @@ def testGroupDescription(self): self.exitRule() return localctx - class TestCaseContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.functionName = None # Token + self.functionName = None # Token def OPAREN(self): return self.getToken(FuncTestCaseParser.OPAREN, 0) def arguments(self): - return self.getTypedRuleContext(FuncTestCaseParser.ArgumentsContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentsContext, 0) def CPAREN(self): return self.getToken(FuncTestCaseParser.CPAREN, 0) @@ -694,8 +4138,7 @@ def EQ(self): return self.getToken(FuncTestCaseParser.EQ, 0) def result(self): - return self.getTypedRuleContext(FuncTestCaseParser.ResultContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.ResultContext, 0) def IDENTIFIER(self): return self.getToken(FuncTestCaseParser.IDENTIFIER, 0) @@ -704,8 +4147,7 @@ def OBRACKET(self): return self.getToken(FuncTestCaseParser.OBRACKET, 0) def func_options(self): - return self.getTypedRuleContext(FuncTestCaseParser.Func_optionsContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.Func_optionsContext, 0) def CBRACKET(self): return self.getToken(FuncTestCaseParser.CBRACKET, 0) @@ -713,28 +4155,25 @@ def CBRACKET(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_testCase - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTestCase" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestCase"): listener.enterTestCase(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTestCase" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestCase"): listener.exitTestCase(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTestCase" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestCase"): return visitor.visitTestCase(self) else: return visitor.visitChildren(self) - - - def testCase(self): localctx = FuncTestCaseParser.TestCaseContext(self, self._ctx, self.state) self.enterRule(localctx, 10, self.RULE_testCase) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 115 @@ -748,7 +4187,7 @@ def testCase(self): self.state = 123 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==88: + if _la == 88: self.state = 119 self.match(FuncTestCaseParser.OBRACKET) self.state = 120 @@ -756,7 +4195,6 @@ def testCase(self): self.state = 121 self.match(FuncTestCaseParser.CBRACKET) - self.state = 125 self.match(FuncTestCaseParser.EQ) self.state = 126 @@ -769,64 +4207,62 @@ def testCase(self): self.exitRule() return localctx - class TestGroupContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def testGroupDescription(self): - return self.getTypedRuleContext(FuncTestCaseParser.TestGroupDescriptionContext,0) - + return self.getTypedRuleContext( + FuncTestCaseParser.TestGroupDescriptionContext, 0 + ) - def testCase(self, i:int=None): + def testCase(self, i: int = None): if i is None: return self.getTypedRuleContexts(FuncTestCaseParser.TestCaseContext) else: - return self.getTypedRuleContext(FuncTestCaseParser.TestCaseContext,i) - + return self.getTypedRuleContext(FuncTestCaseParser.TestCaseContext, i) def getRuleIndex(self): return FuncTestCaseParser.RULE_testGroup - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTestGroup" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTestGroup"): listener.enterTestGroup(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTestGroup" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTestGroup"): listener.exitTestGroup(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTestGroup" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTestGroup"): return visitor.visitTestGroup(self) else: return visitor.visitChildren(self) - - - def testGroup(self): localctx = FuncTestCaseParser.TestGroupContext(self, self._ctx, self.state) self.enterRule(localctx, 12, self.RULE_testGroup) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 128 self.testGroupDescription() - self.state = 130 + self.state = 130 self._errHandler.sync(self) _la = self._input.LA(1) while True: self.state = 129 self.testCase() - self.state = 132 + self.state = 132 self._errHandler.sync(self) _la = self._input.LA(1) - if not (_la==83): + if not (_la == 83): break except RecognitionException as re: @@ -837,22 +4273,22 @@ def testGroup(self): self.exitRule() return localctx - class ArgumentsContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def argument(self, i:int=None): + def argument(self, i: int = None): if i is None: return self.getTypedRuleContexts(FuncTestCaseParser.ArgumentContext) else: - return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext,i) + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext, i) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(FuncTestCaseParser.COMMA) else: @@ -861,28 +4297,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return FuncTestCaseParser.RULE_arguments - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArguments" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArguments"): listener.enterArguments(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArguments" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArguments"): listener.exitArguments(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArguments" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArguments"): return visitor.visitArguments(self) else: return visitor.visitChildren(self) - - - def arguments(self): localctx = FuncTestCaseParser.ArgumentsContext(self, self._ctx, self.state) self.enterRule(localctx, 14, self.RULE_arguments) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 134 @@ -890,7 +4323,7 @@ def arguments(self): self.state = 139 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==90: + while _la == 90: self.state = 135 self.match(FuncTestCaseParser.COMMA) self.state = 136 @@ -907,42 +4340,38 @@ def arguments(self): self.exitRule() return localctx - class ResultContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def argument(self): - return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.ArgumentContext, 0) def substraitError(self): - return self.getTypedRuleContext(FuncTestCaseParser.SubstraitErrorContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.SubstraitErrorContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_result - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterResult" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterResult"): listener.enterResult(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitResult" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitResult"): listener.exitResult(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitResult" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitResult"): return visitor.visitResult(self) else: return visitor.visitChildren(self) - - - def result(self): localctx = FuncTestCaseParser.ResultContext(self, self._ctx, self.state) @@ -972,98 +4401,82 @@ def result(self): self.exitRule() return localctx - class ArgumentContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def nullArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.NullArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.NullArgContext, 0) def i8Arg(self): - return self.getTypedRuleContext(FuncTestCaseParser.I8ArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.I8ArgContext, 0) def i16Arg(self): - return self.getTypedRuleContext(FuncTestCaseParser.I16ArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.I16ArgContext, 0) def i32Arg(self): - return self.getTypedRuleContext(FuncTestCaseParser.I32ArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.I32ArgContext, 0) def i64Arg(self): - return self.getTypedRuleContext(FuncTestCaseParser.I64ArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.I64ArgContext, 0) def fp32Arg(self): - return self.getTypedRuleContext(FuncTestCaseParser.Fp32ArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.Fp32ArgContext, 0) def fp64Arg(self): - return self.getTypedRuleContext(FuncTestCaseParser.Fp64ArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.Fp64ArgContext, 0) def booleanArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.BooleanArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.BooleanArgContext, 0) def stringArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.StringArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.StringArgContext, 0) def decimalArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.DecimalArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.DecimalArgContext, 0) def dateArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.DateArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.DateArgContext, 0) def timeArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.TimeArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.TimeArgContext, 0) def timestampArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.TimestampArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.TimestampArgContext, 0) def timestampTzArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.TimestampTzArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.TimestampTzArgContext, 0) def intervalYearArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.IntervalYearArgContext,0) - + return self.getTypedRuleContext( + FuncTestCaseParser.IntervalYearArgContext, 0 + ) def intervalDayArg(self): - return self.getTypedRuleContext(FuncTestCaseParser.IntervalDayArgContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.IntervalDayArgContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_argument - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterArgument" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterArgument"): listener.enterArgument(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitArgument" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitArgument"): listener.exitArgument(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitArgument" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitArgument"): return visitor.visitArgument(self) else: return visitor.visitChildren(self) - - - def argument(self): localctx = FuncTestCaseParser.ArgumentContext(self, self._ctx, self.state) @@ -1071,7 +4484,7 @@ def argument(self): try: self.state = 162 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,6,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 6, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 146 @@ -1168,7 +4581,6 @@ def argument(self): self.intervalDayArg() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -1177,11 +4589,12 @@ def argument(self): self.exitRule() return localctx - class NumericLiteralContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1197,33 +4610,30 @@ def FLOAT_LITERAL(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_numericLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNumericLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNumericLiteral"): listener.enterNumericLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNumericLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNumericLiteral"): listener.exitNumericLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNumericLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNumericLiteral"): return visitor.visitNumericLiteral(self) else: return visitor.visitChildren(self) - - - def numericLiteral(self): localctx = FuncTestCaseParser.NumericLiteralContext(self, self._ctx, self.state) self.enterRule(localctx, 20, self.RULE_numericLiteral) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 164 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 114688) != 0)): + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 114688) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -1236,11 +4646,12 @@ def numericLiteral(self): self.exitRule() return localctx - class NullArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1251,29 +4662,25 @@ def DOUBLE_COLON(self): return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) def datatype(self): - return self.getTypedRuleContext(FuncTestCaseParser.DatatypeContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.DatatypeContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_nullArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterNullArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterNullArg"): listener.enterNullArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitNullArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitNullArg"): listener.exitNullArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitNullArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitNullArg"): return visitor.visitNullArg(self) else: return visitor.visitChildren(self) - - - def nullArg(self): localctx = FuncTestCaseParser.NullArgContext(self, self._ctx, self.state) @@ -1294,11 +4701,12 @@ def nullArg(self): self.exitRule() return localctx - class I8ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1314,23 +4722,20 @@ def I8(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_i8Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI8Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI8Arg"): listener.enterI8Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI8Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI8Arg"): listener.exitI8Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI8Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI8Arg"): return visitor.visitI8Arg(self) else: return visitor.visitChildren(self) - - - def i8Arg(self): localctx = FuncTestCaseParser.I8ArgContext(self, self._ctx, self.state) @@ -1351,11 +4756,12 @@ def i8Arg(self): self.exitRule() return localctx - class I16ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1371,23 +4777,20 @@ def I16(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_i16Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI16Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI16Arg"): listener.enterI16Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI16Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI16Arg"): listener.exitI16Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI16Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI16Arg"): return visitor.visitI16Arg(self) else: return visitor.visitChildren(self) - - - def i16Arg(self): localctx = FuncTestCaseParser.I16ArgContext(self, self._ctx, self.state) @@ -1408,11 +4811,12 @@ def i16Arg(self): self.exitRule() return localctx - class I32ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1428,23 +4832,20 @@ def I32(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_i32Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI32Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI32Arg"): listener.enterI32Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI32Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI32Arg"): listener.exitI32Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI32Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI32Arg"): return visitor.visitI32Arg(self) else: return visitor.visitChildren(self) - - - def i32Arg(self): localctx = FuncTestCaseParser.I32ArgContext(self, self._ctx, self.state) @@ -1465,11 +4866,12 @@ def i32Arg(self): self.exitRule() return localctx - class I64ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1485,23 +4887,20 @@ def I64(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_i64Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI64Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI64Arg"): listener.enterI64Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI64Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI64Arg"): listener.exitI64Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI64Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI64Arg"): return visitor.visitI64Arg(self) else: return visitor.visitChildren(self) - - - def i64Arg(self): localctx = FuncTestCaseParser.I64ArgContext(self, self._ctx, self.state) @@ -1522,17 +4921,17 @@ def i64Arg(self): self.exitRule() return localctx - class Fp32ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def numericLiteral(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext, 0) def DOUBLE_COLON(self): return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) @@ -1543,23 +4942,20 @@ def FP32(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_fp32Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp32Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp32Arg"): listener.enterFp32Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp32Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp32Arg"): listener.exitFp32Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp32Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp32Arg"): return visitor.visitFp32Arg(self) else: return visitor.visitChildren(self) - - - def fp32Arg(self): localctx = FuncTestCaseParser.Fp32ArgContext(self, self._ctx, self.state) @@ -1580,17 +4976,17 @@ def fp32Arg(self): self.exitRule() return localctx - class Fp64ArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def numericLiteral(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext, 0) def DOUBLE_COLON(self): return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) @@ -1601,23 +4997,20 @@ def FP64(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_fp64Arg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp64Arg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp64Arg"): listener.enterFp64Arg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp64Arg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp64Arg"): listener.exitFp64Arg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp64Arg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp64Arg"): return visitor.visitFp64Arg(self) else: return visitor.visitChildren(self) - - - def fp64Arg(self): localctx = FuncTestCaseParser.Fp64ArgContext(self, self._ctx, self.state) @@ -1638,45 +5031,41 @@ def fp64Arg(self): self.exitRule() return localctx - class DecimalArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def numericLiteral(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.NumericLiteralContext, 0) def DOUBLE_COLON(self): return self.getToken(FuncTestCaseParser.DOUBLE_COLON, 0) def decimalType(self): - return self.getTypedRuleContext(FuncTestCaseParser.DecimalTypeContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.DecimalTypeContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_decimalArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDecimalArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDecimalArg"): listener.enterDecimalArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDecimalArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDecimalArg"): listener.exitDecimalArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDecimalArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDecimalArg"): return visitor.visitDecimalArg(self) else: return visitor.visitChildren(self) - - - def decimalArg(self): localctx = FuncTestCaseParser.DecimalArgContext(self, self._ctx, self.state) @@ -1697,11 +5086,12 @@ def decimalArg(self): self.exitRule() return localctx - class BooleanArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1717,23 +5107,20 @@ def Bool(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_booleanArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBooleanArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBooleanArg"): listener.enterBooleanArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBooleanArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBooleanArg"): listener.exitBooleanArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBooleanArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBooleanArg"): return visitor.visitBooleanArg(self) else: return visitor.visitChildren(self) - - - def booleanArg(self): localctx = FuncTestCaseParser.BooleanArgContext(self, self._ctx, self.state) @@ -1754,11 +5141,12 @@ def booleanArg(self): self.exitRule() return localctx - class StringArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1774,23 +5162,20 @@ def Str(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_stringArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterStringArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterStringArg"): listener.enterStringArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitStringArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitStringArg"): listener.exitStringArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitStringArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitStringArg"): return visitor.visitStringArg(self) else: return visitor.visitChildren(self) - - - def stringArg(self): localctx = FuncTestCaseParser.StringArgContext(self, self._ctx, self.state) @@ -1811,11 +5196,12 @@ def stringArg(self): self.exitRule() return localctx - class DateArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1831,23 +5217,20 @@ def Date(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_dateArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDateArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDateArg"): listener.enterDateArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDateArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDateArg"): listener.exitDateArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDateArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDateArg"): return visitor.visitDateArg(self) else: return visitor.visitChildren(self) - - - def dateArg(self): localctx = FuncTestCaseParser.DateArgContext(self, self._ctx, self.state) @@ -1868,11 +5251,12 @@ def dateArg(self): self.exitRule() return localctx - class TimeArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1888,23 +5272,20 @@ def Time(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_timeArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeArg"): listener.enterTimeArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeArg"): listener.exitTimeArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeArg"): return visitor.visitTimeArg(self) else: return visitor.visitChildren(self) - - - def timeArg(self): localctx = FuncTestCaseParser.TimeArgContext(self, self._ctx, self.state) @@ -1925,11 +5306,12 @@ def timeArg(self): self.exitRule() return localctx - class TimestampArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -1945,23 +5327,20 @@ def Ts(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_timestampArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestampArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestampArg"): listener.enterTimestampArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestampArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestampArg"): listener.exitTimestampArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestampArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestampArg"): return visitor.visitTimestampArg(self) else: return visitor.visitChildren(self) - - - def timestampArg(self): localctx = FuncTestCaseParser.TimestampArgContext(self, self._ctx, self.state) @@ -1982,11 +5361,12 @@ def timestampArg(self): self.exitRule() return localctx - class TimestampTzArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -2002,23 +5382,20 @@ def TsTZ(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_timestampTzArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestampTzArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestampTzArg"): listener.enterTimestampTzArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestampTzArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestampTzArg"): listener.exitTimestampTzArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestampTzArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestampTzArg"): return visitor.visitTimestampTzArg(self) else: return visitor.visitChildren(self) - - - def timestampTzArg(self): localctx = FuncTestCaseParser.TimestampTzArgContext(self, self._ctx, self.state) @@ -2039,11 +5416,12 @@ def timestampTzArg(self): self.exitRule() return localctx - class IntervalYearArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -2059,26 +5437,25 @@ def IYear(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_intervalYearArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalYearArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalYearArg"): listener.enterIntervalYearArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalYearArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalYearArg"): listener.exitIntervalYearArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalYearArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalYearArg"): return visitor.visitIntervalYearArg(self) else: return visitor.visitChildren(self) - - - def intervalYearArg(self): - localctx = FuncTestCaseParser.IntervalYearArgContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.IntervalYearArgContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 50, self.RULE_intervalYearArg) try: self.enterOuterAlt(localctx, 1) @@ -2096,11 +5473,12 @@ def intervalYearArg(self): self.exitRule() return localctx - class IntervalDayArgContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -2116,23 +5494,20 @@ def IDay(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_intervalDayArg - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalDayArg" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalDayArg"): listener.enterIntervalDayArg(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalDayArg" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalDayArg"): listener.exitIntervalDayArg(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalDayArg" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalDayArg"): return visitor.visitIntervalDayArg(self) else: return visitor.visitChildren(self) - - - def intervalDayArg(self): localctx = FuncTestCaseParser.IntervalDayArgContext(self, self._ctx, self.state) @@ -2153,15 +5528,16 @@ def intervalDayArg(self): self.exitRule() return localctx - class IntervalYearLiteralContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.years = None # Token - self.months = None # Token + self.years = None # Token + self.months = None # Token def PERIOD_PREFIX(self): return self.getToken(FuncTestCaseParser.PERIOD_PREFIX, 0) @@ -2169,7 +5545,7 @@ def PERIOD_PREFIX(self): def YEAR_SUFFIX(self): return self.getToken(FuncTestCaseParser.YEAR_SUFFIX, 0) - def INTEGER_LITERAL(self, i:int=None): + def INTEGER_LITERAL(self, i: int = None): if i is None: return self.getTokens(FuncTestCaseParser.INTEGER_LITERAL) else: @@ -2181,32 +5557,31 @@ def M_SUFFIX(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_intervalYearLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalYearLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalYearLiteral"): listener.enterIntervalYearLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalYearLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalYearLiteral"): listener.exitIntervalYearLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalYearLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalYearLiteral"): return visitor.visitIntervalYearLiteral(self) else: return visitor.visitChildren(self) - - - def intervalYearLiteral(self): - localctx = FuncTestCaseParser.IntervalYearLiteralContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.IntervalYearLiteralContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 54, self.RULE_intervalYearLiteral) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 241 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,8,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 8, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 230 @@ -2219,13 +5594,12 @@ def intervalYearLiteral(self): self.state = 236 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 234 localctx.months = self.match(FuncTestCaseParser.INTEGER_LITERAL) self.state = 235 self.match(FuncTestCaseParser.M_SUFFIX) - pass elif la_ == 2: @@ -2239,7 +5613,6 @@ def intervalYearLiteral(self): self.match(FuncTestCaseParser.M_SUFFIX) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2248,14 +5621,15 @@ def intervalYearLiteral(self): self.exitRule() return localctx - class IntervalDayLiteralContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.days = None # Token + self.days = None # Token def PERIOD_PREFIX(self): return self.getToken(FuncTestCaseParser.PERIOD_PREFIX, 0) @@ -2270,38 +5644,36 @@ def TIME_PREFIX(self): return self.getToken(FuncTestCaseParser.TIME_PREFIX, 0) def timeInterval(self): - return self.getTypedRuleContext(FuncTestCaseParser.TimeIntervalContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.TimeIntervalContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_intervalDayLiteral - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalDayLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalDayLiteral"): listener.enterIntervalDayLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalDayLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalDayLiteral"): listener.exitIntervalDayLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalDayLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalDayLiteral"): return visitor.visitIntervalDayLiteral(self) else: return visitor.visitChildren(self) - - - def intervalDayLiteral(self): - localctx = FuncTestCaseParser.IntervalDayLiteralContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.IntervalDayLiteralContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 56, self.RULE_intervalDayLiteral) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 254 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,10,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 10, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 243 @@ -2314,13 +5686,12 @@ def intervalDayLiteral(self): self.state = 249 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==23: + if _la == 23: self.state = 247 self.match(FuncTestCaseParser.TIME_PREFIX) self.state = 248 self.timeInterval() - pass elif la_ == 2: @@ -2333,7 +5704,6 @@ def intervalDayLiteral(self): self.timeInterval() pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2342,22 +5712,23 @@ def intervalDayLiteral(self): self.exitRule() return localctx - class TimeIntervalContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - self.hours = None # Token - self.minutes = None # Token - self.seconds = None # Token - self.fractionalSeconds = None # Token + self.hours = None # Token + self.minutes = None # Token + self.seconds = None # Token + self.fractionalSeconds = None # Token def HOUR_SUFFIX(self): return self.getToken(FuncTestCaseParser.HOUR_SUFFIX, 0) - def INTEGER_LITERAL(self, i:int=None): + def INTEGER_LITERAL(self, i: int = None): if i is None: return self.getTokens(FuncTestCaseParser.INTEGER_LITERAL) else: @@ -2375,32 +5746,29 @@ def FRACTIONAL_SECOND_SUFFIX(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_timeInterval - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimeInterval" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimeInterval"): listener.enterTimeInterval(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimeInterval" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimeInterval"): listener.exitTimeInterval(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimeInterval" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimeInterval"): return visitor.visitTimeInterval(self) else: return visitor.visitChildren(self) - - - def timeInterval(self): localctx = FuncTestCaseParser.TimeIntervalContext(self, self._ctx, self.state) self.enterRule(localctx, 58, self.RULE_timeInterval) - self._la = 0 # Token type + self._la = 0 # Token type try: self.state = 288 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,17,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 17, self._ctx) if la_ == 1: self.enterOuterAlt(localctx, 1) self.state = 256 @@ -2409,34 +5777,33 @@ def timeInterval(self): self.match(FuncTestCaseParser.HOUR_SUFFIX) self.state = 260 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,11,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 11, self._ctx) if la_ == 1: self.state = 258 localctx.minutes = self.match(FuncTestCaseParser.INTEGER_LITERAL) self.state = 259 self.match(FuncTestCaseParser.M_SUFFIX) - self.state = 264 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,12,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 12, self._ctx) if la_ == 1: self.state = 262 localctx.seconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) self.state = 263 self.match(FuncTestCaseParser.SECOND_SUFFIX) - self.state = 268 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 266 - localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + localctx.fractionalSeconds = self.match( + FuncTestCaseParser.INTEGER_LITERAL + ) self.state = 267 self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) - pass elif la_ == 2: @@ -2447,24 +5814,24 @@ def timeInterval(self): self.match(FuncTestCaseParser.M_SUFFIX) self.state = 274 self._errHandler.sync(self) - la_ = self._interp.adaptivePredict(self._input,14,self._ctx) + la_ = self._interp.adaptivePredict(self._input, 14, self._ctx) if la_ == 1: self.state = 272 localctx.seconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) self.state = 273 self.match(FuncTestCaseParser.SECOND_SUFFIX) - self.state = 278 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 276 - localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + localctx.fractionalSeconds = self.match( + FuncTestCaseParser.INTEGER_LITERAL + ) self.state = 277 self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) - pass elif la_ == 3: @@ -2476,24 +5843,26 @@ def timeInterval(self): self.state = 284 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==14: + if _la == 14: self.state = 282 - localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + localctx.fractionalSeconds = self.match( + FuncTestCaseParser.INTEGER_LITERAL + ) self.state = 283 self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) - pass elif la_ == 4: self.enterOuterAlt(localctx, 4) self.state = 286 - localctx.fractionalSeconds = self.match(FuncTestCaseParser.INTEGER_LITERAL) + localctx.fractionalSeconds = self.match( + FuncTestCaseParser.INTEGER_LITERAL + ) self.state = 287 self.match(FuncTestCaseParser.FRACTIONAL_SECOND_SUFFIX) pass - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -2502,42 +5871,40 @@ def timeInterval(self): self.exitRule() return localctx - class DatatypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def scalarType(self): - return self.getTypedRuleContext(FuncTestCaseParser.ScalarTypeContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.ScalarTypeContext, 0) def parameterizedType(self): - return self.getTypedRuleContext(FuncTestCaseParser.ParameterizedTypeContext,0) - + return self.getTypedRuleContext( + FuncTestCaseParser.ParameterizedTypeContext, 0 + ) def getRuleIndex(self): return FuncTestCaseParser.RULE_datatype - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDatatype" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDatatype"): listener.enterDatatype(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDatatype" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDatatype"): listener.exitDatatype(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDatatype" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDatatype"): return visitor.visitDatatype(self) else: return visitor.visitChildren(self) - - - def datatype(self): localctx = FuncTestCaseParser.DatatypeContext(self, self._ctx, self.state) @@ -2546,7 +5913,25 @@ def datatype(self): self.state = 292 self._errHandler.sync(self) token = self._input.LA(1) - if token in [41, 42, 43, 44, 45, 46, 48, 51, 52, 55, 67, 69, 70, 72, 73, 74, 75]: + if token in [ + 41, + 42, + 43, + 44, + 45, + 46, + 48, + 51, + 52, + 55, + 67, + 69, + 70, + 72, + 73, + 74, + 75, + ]: self.enterOuterAlt(localctx, 1) self.state = 290 self.scalarType() @@ -2567,435 +5952,449 @@ def datatype(self): self.exitRule() return localctx - class ScalarTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_scalarType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DateContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Date(self): return self.getToken(FuncTestCaseParser.Date, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDate" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDate"): listener.enterDate(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDate" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDate"): listener.exitDate(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDate" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDate"): return visitor.visitDate(self) else: return visitor.visitChildren(self) - class StringContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Str(self): return self.getToken(FuncTestCaseParser.Str, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterString" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterString"): listener.enterString(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitString" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitString"): listener.exitString(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitString" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitString"): return visitor.visitString(self) else: return visitor.visitChildren(self) - class I64Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I64(self): return self.getToken(FuncTestCaseParser.I64, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI64" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI64"): listener.enterI64(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI64" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI64"): listener.exitI64(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI64" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI64"): return visitor.visitI64(self) else: return visitor.visitChildren(self) - class UserDefinedContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def UserDefined(self): return self.getToken(FuncTestCaseParser.UserDefined, 0) + def IDENTIFIER(self): return self.getToken(FuncTestCaseParser.IDENTIFIER, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUserDefined" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUserDefined"): listener.enterUserDefined(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUserDefined" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUserDefined"): listener.exitUserDefined(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUserDefined" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUserDefined"): return visitor.visitUserDefined(self) else: return visitor.visitChildren(self) - class I32Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I32(self): return self.getToken(FuncTestCaseParser.I32, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI32" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI32"): listener.enterI32(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI32" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI32"): listener.exitI32(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI32" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI32"): return visitor.visitI32(self) else: return visitor.visitChildren(self) - class IntervalYearContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def IYear(self): return self.getToken(FuncTestCaseParser.IYear, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalYear" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalYear"): listener.enterIntervalYear(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalYear" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalYear"): listener.exitIntervalYear(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalYear" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalYear"): return visitor.visitIntervalYear(self) else: return visitor.visitChildren(self) - class UuidContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def UUID(self): return self.getToken(FuncTestCaseParser.UUID, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterUuid" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterUuid"): listener.enterUuid(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitUuid" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitUuid"): listener.exitUuid(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitUuid" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitUuid"): return visitor.visitUuid(self) else: return visitor.visitChildren(self) - class I8Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I8(self): return self.getToken(FuncTestCaseParser.I8, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI8" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI8"): listener.enterI8(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI8" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI8"): listener.exitI8(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI8" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI8"): return visitor.visitI8(self) else: return visitor.visitChildren(self) - class I16Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def I16(self): return self.getToken(FuncTestCaseParser.I16, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterI16" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterI16"): listener.enterI16(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitI16" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitI16"): listener.exitI16(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitI16" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitI16"): return visitor.visitI16(self) else: return visitor.visitChildren(self) - class BinaryContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Binary(self): return self.getToken(FuncTestCaseParser.Binary, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBinary" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBinary"): listener.enterBinary(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBinary" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBinary"): listener.exitBinary(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBinary" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBinary"): return visitor.visitBinary(self) else: return visitor.visitChildren(self) - class IntervalDayContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def IDay(self): return self.getToken(FuncTestCaseParser.IDay, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntervalDay" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntervalDay"): listener.enterIntervalDay(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntervalDay" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntervalDay"): listener.exitIntervalDay(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntervalDay" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntervalDay"): return visitor.visitIntervalDay(self) else: return visitor.visitChildren(self) - class Fp64Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def FP64(self): return self.getToken(FuncTestCaseParser.FP64, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp64" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp64"): listener.enterFp64(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp64" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp64"): listener.exitFp64(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp64" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp64"): return visitor.visitFp64(self) else: return visitor.visitChildren(self) - class Fp32Context(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def FP32(self): return self.getToken(FuncTestCaseParser.FP32, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFp32" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFp32"): listener.enterFp32(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFp32" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFp32"): listener.exitFp32(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFp32" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFp32"): return visitor.visitFp32(self) else: return visitor.visitChildren(self) - class TimeContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Time(self): return self.getToken(FuncTestCaseParser.Time, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTime" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTime"): listener.enterTime(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTime" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTime"): listener.exitTime(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTime" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTime"): return visitor.visitTime(self) else: return visitor.visitChildren(self) - class BooleanContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Bool(self): return self.getToken(FuncTestCaseParser.Bool, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterBoolean" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterBoolean"): listener.enterBoolean(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitBoolean" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitBoolean"): listener.exitBoolean(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitBoolean" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitBoolean"): return visitor.visitBoolean(self) else: return visitor.visitChildren(self) - class TimestampContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def Ts(self): return self.getToken(FuncTestCaseParser.Ts, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestamp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestamp"): listener.enterTimestamp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestamp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestamp"): listener.exitTimestamp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestamp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestamp"): return visitor.visitTimestamp(self) else: return visitor.visitChildren(self) - class TimestampTzContext(ScalarTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.ScalarTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.ScalarTypeContext super().__init__(parser) self.copyFrom(ctx) def TsTZ(self): return self.getToken(FuncTestCaseParser.TsTZ, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterTimestampTz" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterTimestampTz"): listener.enterTimestampTz(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitTimestampTz" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitTimestampTz"): listener.exitTimestampTz(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitTimestampTz" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitTimestampTz"): return visitor.visitTimestampTz(self) else: return visitor.visitChildren(self) - - def scalarType(self): localctx = FuncTestCaseParser.ScalarTypeContext(self, self._ctx, self.state) @@ -3119,65 +6518,67 @@ def scalarType(self): self.exitRule() return localctx - class FixedCharTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_fixedCharType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class FixedCharContext(FixedCharTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.FixedCharTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.FixedCharTypeContext super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext + self.isnull = None # Token + self.len_ = None # NumericParameterContext self.copyFrom(ctx) def FChar(self): return self.getToken(FuncTestCaseParser.FChar, 0) + def O_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + return self.getTypedRuleContext( + FuncTestCaseParser.NumericParameterContext, 0 + ) def QMARK(self): return self.getToken(FuncTestCaseParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFixedChar" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFixedChar"): listener.enterFixedChar(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFixedChar" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFixedChar"): listener.exitFixedChar(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFixedChar" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFixedChar"): return visitor.visitFixedChar(self) else: return visitor.visitChildren(self) - - def fixedCharType(self): localctx = FuncTestCaseParser.FixedCharTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 64, self.RULE_fixedCharType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = FuncTestCaseParser.FixedCharContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3186,11 +6587,10 @@ def fixedCharType(self): self.state = 316 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==93: + if _la == 93: self.state = 315 localctx.isnull = self.match(FuncTestCaseParser.QMARK) - self.state = 318 self.match(FuncTestCaseParser.O_ANGLE_BRACKET) self.state = 319 @@ -3205,65 +6605,67 @@ def fixedCharType(self): self.exitRule() return localctx - class VarCharTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_varCharType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class VarCharContext(VarCharTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.VarCharTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.VarCharTypeContext super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext + self.isnull = None # Token + self.len_ = None # NumericParameterContext self.copyFrom(ctx) def VChar(self): return self.getToken(FuncTestCaseParser.VChar, 0) + def O_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + return self.getTypedRuleContext( + FuncTestCaseParser.NumericParameterContext, 0 + ) def QMARK(self): return self.getToken(FuncTestCaseParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterVarChar" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterVarChar"): listener.enterVarChar(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitVarChar" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitVarChar"): listener.exitVarChar(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitVarChar" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitVarChar"): return visitor.visitVarChar(self) else: return visitor.visitChildren(self) - - def varCharType(self): localctx = FuncTestCaseParser.VarCharTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 66, self.RULE_varCharType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = FuncTestCaseParser.VarCharContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3272,11 +6674,10 @@ def varCharType(self): self.state = 324 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==93: + if _la == 93: self.state = 323 localctx.isnull = self.match(FuncTestCaseParser.QMARK) - self.state = 326 self.match(FuncTestCaseParser.O_ANGLE_BRACKET) self.state = 327 @@ -3291,65 +6692,69 @@ def varCharType(self): self.exitRule() return localctx - class FixedBinaryTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_fixedBinaryType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class FixedBinaryContext(FixedBinaryTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.FixedBinaryTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.FixedBinaryTypeContext super().__init__(parser) - self.isnull = None # Token - self.len_ = None # NumericParameterContext + self.isnull = None # Token + self.len_ = None # NumericParameterContext self.copyFrom(ctx) def FBin(self): return self.getToken(FuncTestCaseParser.FBin, 0) + def O_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + return self.getTypedRuleContext( + FuncTestCaseParser.NumericParameterContext, 0 + ) def QMARK(self): return self.getToken(FuncTestCaseParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFixedBinary" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFixedBinary"): listener.enterFixedBinary(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFixedBinary" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFixedBinary"): listener.exitFixedBinary(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFixedBinary" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFixedBinary"): return visitor.visitFixedBinary(self) else: return visitor.visitChildren(self) - - def fixedBinaryType(self): - localctx = FuncTestCaseParser.FixedBinaryTypeContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.FixedBinaryTypeContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 68, self.RULE_fixedBinaryType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = FuncTestCaseParser.FixedBinaryContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3358,11 +6763,10 @@ def fixedBinaryType(self): self.state = 332 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==93: + if _la == 93: self.state = 331 localctx.isnull = self.match(FuncTestCaseParser.QMARK) - self.state = 334 self.match(FuncTestCaseParser.O_ANGLE_BRACKET) self.state = 335 @@ -3377,71 +6781,76 @@ def fixedBinaryType(self): self.exitRule() return localctx - class DecimalTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_decimalType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class DecimalContext(DecimalTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.DecimalTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.DecimalTypeContext super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext - self.scale = None # NumericParameterContext + self.isnull = None # Token + self.precision = None # NumericParameterContext + self.scale = None # NumericParameterContext self.copyFrom(ctx) def Dec(self): return self.getToken(FuncTestCaseParser.Dec, 0) + def O_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def COMMA(self): return self.getToken(FuncTestCaseParser.COMMA, 0) + def C_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def QMARK(self): return self.getToken(FuncTestCaseParser.QMARK, 0) - def numericParameter(self, i:int=None): + + def numericParameter(self, i: int = None): if i is None: - return self.getTypedRuleContexts(FuncTestCaseParser.NumericParameterContext) + return self.getTypedRuleContexts( + FuncTestCaseParser.NumericParameterContext + ) else: - return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,i) - + return self.getTypedRuleContext( + FuncTestCaseParser.NumericParameterContext, i + ) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterDecimal" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterDecimal"): listener.enterDecimal(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitDecimal" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitDecimal"): listener.exitDecimal(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitDecimal" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitDecimal"): return visitor.visitDecimal(self) else: return visitor.visitChildren(self) - - def decimalType(self): localctx = FuncTestCaseParser.DecimalTypeContext(self, self._ctx, self.state) self.enterRule(localctx, 70, self.RULE_decimalType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = FuncTestCaseParser.DecimalContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3450,15 +6859,14 @@ def decimalType(self): self.state = 340 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==93: + if _la == 93: self.state = 339 localctx.isnull = self.match(FuncTestCaseParser.QMARK) - self.state = 348 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==84: + if _la == 84: self.state = 342 self.match(FuncTestCaseParser.O_ANGLE_BRACKET) self.state = 343 @@ -3470,7 +6878,6 @@ def decimalType(self): self.state = 346 self.match(FuncTestCaseParser.C_ANGLE_BRACKET) - except RecognitionException as re: localctx.exception = re self._errHandler.reportError(self, re) @@ -3479,65 +6886,69 @@ def decimalType(self): self.exitRule() return localctx - class PrecisionTimestampTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_precisionTimestampType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class PrecisionTimestampContext(PrecisionTimestampTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.PrecisionTimestampTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.PrecisionTimestampTypeContext super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext + self.isnull = None # Token + self.precision = None # NumericParameterContext self.copyFrom(ctx) def PTs(self): return self.getToken(FuncTestCaseParser.PTs, 0) + def O_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + return self.getTypedRuleContext( + FuncTestCaseParser.NumericParameterContext, 0 + ) def QMARK(self): return self.getToken(FuncTestCaseParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPrecisionTimestamp" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPrecisionTimestamp"): listener.enterPrecisionTimestamp(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPrecisionTimestamp" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPrecisionTimestamp"): listener.exitPrecisionTimestamp(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPrecisionTimestamp" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPrecisionTimestamp"): return visitor.visitPrecisionTimestamp(self) else: return visitor.visitChildren(self) - - def precisionTimestampType(self): - localctx = FuncTestCaseParser.PrecisionTimestampTypeContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.PrecisionTimestampTypeContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 72, self.RULE_precisionTimestampType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = FuncTestCaseParser.PrecisionTimestampContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3546,11 +6957,10 @@ def precisionTimestampType(self): self.state = 352 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==93: + if _la == 93: self.state = 351 localctx.isnull = self.match(FuncTestCaseParser.QMARK) - self.state = 354 self.match(FuncTestCaseParser.O_ANGLE_BRACKET) self.state = 355 @@ -3565,65 +6975,69 @@ def precisionTimestampType(self): self.exitRule() return localctx - class PrecisionTimestampTZTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_precisionTimestampTZType - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class PrecisionTimestampTZContext(PrecisionTimestampTZTypeContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.PrecisionTimestampTZTypeContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.PrecisionTimestampTZTypeContext super().__init__(parser) - self.isnull = None # Token - self.precision = None # NumericParameterContext + self.isnull = None # Token + self.precision = None # NumericParameterContext self.copyFrom(ctx) def PTsTZ(self): return self.getToken(FuncTestCaseParser.PTsTZ, 0) + def O_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.O_ANGLE_BRACKET, 0) + def C_ANGLE_BRACKET(self): return self.getToken(FuncTestCaseParser.C_ANGLE_BRACKET, 0) + def numericParameter(self): - return self.getTypedRuleContext(FuncTestCaseParser.NumericParameterContext,0) + return self.getTypedRuleContext( + FuncTestCaseParser.NumericParameterContext, 0 + ) def QMARK(self): return self.getToken(FuncTestCaseParser.QMARK, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterPrecisionTimestampTZ" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterPrecisionTimestampTZ"): listener.enterPrecisionTimestampTZ(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitPrecisionTimestampTZ" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitPrecisionTimestampTZ"): listener.exitPrecisionTimestampTZ(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitPrecisionTimestampTZ" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitPrecisionTimestampTZ"): return visitor.visitPrecisionTimestampTZ(self) else: return visitor.visitChildren(self) - - def precisionTimestampTZType(self): - localctx = FuncTestCaseParser.PrecisionTimestampTZTypeContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.PrecisionTimestampTZTypeContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 74, self.RULE_precisionTimestampTZType) - self._la = 0 # Token type + self._la = 0 # Token type try: localctx = FuncTestCaseParser.PrecisionTimestampTZContext(self, localctx) self.enterOuterAlt(localctx, 1) @@ -3632,11 +7046,10 @@ def precisionTimestampTZType(self): self.state = 360 self._errHandler.sync(self) _la = self._input.LA(1) - if _la==93: + if _la == 93: self.state = 359 localctx.isnull = self.match(FuncTestCaseParser.QMARK) - self.state = 362 self.match(FuncTestCaseParser.O_ANGLE_BRACKET) self.state = 363 @@ -3651,61 +7064,61 @@ def precisionTimestampTZType(self): self.exitRule() return localctx - class ParameterizedTypeContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def fixedCharType(self): - return self.getTypedRuleContext(FuncTestCaseParser.FixedCharTypeContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.FixedCharTypeContext, 0) def varCharType(self): - return self.getTypedRuleContext(FuncTestCaseParser.VarCharTypeContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.VarCharTypeContext, 0) def fixedBinaryType(self): - return self.getTypedRuleContext(FuncTestCaseParser.FixedBinaryTypeContext,0) - + return self.getTypedRuleContext( + FuncTestCaseParser.FixedBinaryTypeContext, 0 + ) def decimalType(self): - return self.getTypedRuleContext(FuncTestCaseParser.DecimalTypeContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.DecimalTypeContext, 0) def precisionTimestampType(self): - return self.getTypedRuleContext(FuncTestCaseParser.PrecisionTimestampTypeContext,0) - + return self.getTypedRuleContext( + FuncTestCaseParser.PrecisionTimestampTypeContext, 0 + ) def precisionTimestampTZType(self): - return self.getTypedRuleContext(FuncTestCaseParser.PrecisionTimestampTZTypeContext,0) - + return self.getTypedRuleContext( + FuncTestCaseParser.PrecisionTimestampTZTypeContext, 0 + ) def getRuleIndex(self): return FuncTestCaseParser.RULE_parameterizedType - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterParameterizedType" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterParameterizedType"): listener.enterParameterizedType(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitParameterizedType" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitParameterizedType"): listener.exitParameterizedType(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitParameterizedType" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitParameterizedType"): return visitor.visitParameterizedType(self) else: return visitor.visitChildren(self) - - - def parameterizedType(self): - localctx = FuncTestCaseParser.ParameterizedTypeContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.ParameterizedTypeContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 76, self.RULE_parameterizedType) try: self.state = 372 @@ -3752,52 +7165,51 @@ def parameterizedType(self): self.exitRule() return localctx - class NumericParameterContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def getRuleIndex(self): return FuncTestCaseParser.RULE_numericParameter - - def copyFrom(self, ctx:ParserRuleContext): + def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) - - class IntegerLiteralContext(NumericParameterContext): - def __init__(self, parser, ctx:ParserRuleContext): # actually a FuncTestCaseParser.NumericParameterContext + def __init__( + self, parser, ctx: ParserRuleContext + ): # actually a FuncTestCaseParser.NumericParameterContext super().__init__(parser) self.copyFrom(ctx) def INTEGER_LITERAL(self): return self.getToken(FuncTestCaseParser.INTEGER_LITERAL, 0) - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterIntegerLiteral" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterIntegerLiteral"): listener.enterIntegerLiteral(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitIntegerLiteral" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitIntegerLiteral"): listener.exitIntegerLiteral(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitIntegerLiteral" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitIntegerLiteral"): return visitor.visitIntegerLiteral(self) else: return visitor.visitChildren(self) - - def numericParameter(self): - localctx = FuncTestCaseParser.NumericParameterContext(self, self._ctx, self.state) + localctx = FuncTestCaseParser.NumericParameterContext( + self, self._ctx, self.state + ) self.enterRule(localctx, 78, self.RULE_numericParameter) try: localctx = FuncTestCaseParser.IntegerLiteralContext(self, localctx) @@ -3812,11 +7224,12 @@ def numericParameter(self): self.exitRule() return localctx - class SubstraitErrorContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -3829,33 +7242,30 @@ def UNDEFINED_RESULT(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_substraitError - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterSubstraitError" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterSubstraitError"): listener.enterSubstraitError(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitSubstraitError" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitSubstraitError"): listener.exitSubstraitError(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitSubstraitError" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitSubstraitError"): return visitor.visitSubstraitError(self) else: return visitor.visitChildren(self) - - - def substraitError(self): localctx = FuncTestCaseParser.SubstraitErrorContext(self, self._ctx, self.state) self.enterRule(localctx, 80, self.RULE_substraitError) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 376 _la = self._input.LA(1) - if not(_la==5 or _la==6): + if not (_la == 5 or _la == 6): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3868,45 +7278,41 @@ def substraitError(self): self.exitRule() return localctx - class Func_optionContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser def option_name(self): - return self.getTypedRuleContext(FuncTestCaseParser.Option_nameContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.Option_nameContext, 0) def COLON(self): return self.getToken(FuncTestCaseParser.COLON, 0) def option_value(self): - return self.getTypedRuleContext(FuncTestCaseParser.Option_valueContext,0) - + return self.getTypedRuleContext(FuncTestCaseParser.Option_valueContext, 0) def getRuleIndex(self): return FuncTestCaseParser.RULE_func_option - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunc_option" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunc_option"): listener.enterFunc_option(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunc_option" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunc_option"): listener.exitFunc_option(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunc_option" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunc_option"): return visitor.visitFunc_option(self) else: return visitor.visitChildren(self) - - - def func_option(self): localctx = FuncTestCaseParser.Func_optionContext(self, self._ctx, self.state) @@ -3927,11 +7333,12 @@ def func_option(self): self.exitRule() return localctx - class Option_nameContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -3947,33 +7354,30 @@ def IDENTIFIER(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_option_name - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOption_name" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOption_name"): listener.enterOption_name(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOption_name" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOption_name"): listener.exitOption_name(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOption_name" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOption_name"): return visitor.visitOption_name(self) else: return visitor.visitChildren(self) - - - def option_name(self): localctx = FuncTestCaseParser.Option_nameContext(self, self._ctx, self.state) self.enterRule(localctx, 84, self.RULE_option_name) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 382 _la = self._input.LA(1) - if not(_la==7 or _la==8 or _la==83): + if not (_la == 7 or _la == 8 or _la == 83): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -3986,11 +7390,12 @@ def option_name(self): self.exitRule() return localctx - class Option_valueContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser @@ -4012,33 +7417,30 @@ def NAN(self): def getRuleIndex(self): return FuncTestCaseParser.RULE_option_value - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterOption_value" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterOption_value"): listener.enterOption_value(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitOption_value" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitOption_value"): listener.exitOption_value(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitOption_value" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitOption_value"): return visitor.visitOption_value(self) else: return visitor.visitChildren(self) - - - def option_value(self): localctx = FuncTestCaseParser.Option_valueContext(self, self._ctx, self.state) self.enterRule(localctx, 86, self.RULE_option_value) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 384 _la = self._input.LA(1) - if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 15872) != 0)): + if not ((((_la) & ~0x3F) == 0 and ((1 << _la) & 15872) != 0)): self._errHandler.recoverInline(self) else: self._errHandler.reportMatch(self) @@ -4051,22 +7453,24 @@ def option_value(self): self.exitRule() return localctx - class Func_optionsContext(ParserRuleContext): - __slots__ = 'parser' + __slots__ = "parser" - def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + def __init__( + self, parser, parent: ParserRuleContext = None, invokingState: int = -1 + ): super().__init__(parent, invokingState) self.parser = parser - def func_option(self, i:int=None): + def func_option(self, i: int = None): if i is None: return self.getTypedRuleContexts(FuncTestCaseParser.Func_optionContext) else: - return self.getTypedRuleContext(FuncTestCaseParser.Func_optionContext,i) + return self.getTypedRuleContext( + FuncTestCaseParser.Func_optionContext, i + ) - - def COMMA(self, i:int=None): + def COMMA(self, i: int = None): if i is None: return self.getTokens(FuncTestCaseParser.COMMA) else: @@ -4075,28 +7479,25 @@ def COMMA(self, i:int=None): def getRuleIndex(self): return FuncTestCaseParser.RULE_func_options - def enterRule(self, listener:ParseTreeListener): - if hasattr( listener, "enterFunc_options" ): + def enterRule(self, listener: ParseTreeListener): + if hasattr(listener, "enterFunc_options"): listener.enterFunc_options(self) - def exitRule(self, listener:ParseTreeListener): - if hasattr( listener, "exitFunc_options" ): + def exitRule(self, listener: ParseTreeListener): + if hasattr(listener, "exitFunc_options"): listener.exitFunc_options(self) - def accept(self, visitor:ParseTreeVisitor): - if hasattr( visitor, "visitFunc_options" ): + def accept(self, visitor: ParseTreeVisitor): + if hasattr(visitor, "visitFunc_options"): return visitor.visitFunc_options(self) else: return visitor.visitChildren(self) - - - def func_options(self): localctx = FuncTestCaseParser.Func_optionsContext(self, self._ctx, self.state) self.enterRule(localctx, 88, self.RULE_func_options) - self._la = 0 # Token type + self._la = 0 # Token type try: self.enterOuterAlt(localctx, 1) self.state = 386 @@ -4104,7 +7505,7 @@ def func_options(self): self.state = 391 self._errHandler.sync(self) _la = self._input.LA(1) - while _la==90: + while _la == 90: self.state = 387 self.match(FuncTestCaseParser.COMMA) self.state = 388 @@ -4120,8 +7521,3 @@ def func_options(self): finally: self.exitRule() return localctx - - - - - diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py index 496d161a1..830474d71 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py @@ -1,561 +1,518 @@ # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 from antlr4 import * + if "." in __name__: from .FuncTestCaseParser import FuncTestCaseParser else: from FuncTestCaseParser import FuncTestCaseParser + # This class defines a complete listener for a parse tree produced by FuncTestCaseParser. class FuncTestCaseParserListener(ParseTreeListener): # Enter a parse tree produced by FuncTestCaseParser#doc. - def enterDoc(self, ctx:FuncTestCaseParser.DocContext): + def enterDoc(self, ctx: FuncTestCaseParser.DocContext): pass # Exit a parse tree produced by FuncTestCaseParser#doc. - def exitDoc(self, ctx:FuncTestCaseParser.DocContext): + def exitDoc(self, ctx: FuncTestCaseParser.DocContext): pass - # Enter a parse tree produced by FuncTestCaseParser#header. - def enterHeader(self, ctx:FuncTestCaseParser.HeaderContext): + def enterHeader(self, ctx: FuncTestCaseParser.HeaderContext): pass # Exit a parse tree produced by FuncTestCaseParser#header. - def exitHeader(self, ctx:FuncTestCaseParser.HeaderContext): + def exitHeader(self, ctx: FuncTestCaseParser.HeaderContext): pass - # Enter a parse tree produced by FuncTestCaseParser#version. - def enterVersion(self, ctx:FuncTestCaseParser.VersionContext): + def enterVersion(self, ctx: FuncTestCaseParser.VersionContext): pass # Exit a parse tree produced by FuncTestCaseParser#version. - def exitVersion(self, ctx:FuncTestCaseParser.VersionContext): + def exitVersion(self, ctx: FuncTestCaseParser.VersionContext): pass - # Enter a parse tree produced by FuncTestCaseParser#include. - def enterInclude(self, ctx:FuncTestCaseParser.IncludeContext): + def enterInclude(self, ctx: FuncTestCaseParser.IncludeContext): pass # Exit a parse tree produced by FuncTestCaseParser#include. - def exitInclude(self, ctx:FuncTestCaseParser.IncludeContext): + def exitInclude(self, ctx: FuncTestCaseParser.IncludeContext): pass - # Enter a parse tree produced by FuncTestCaseParser#testGroupDescription. - def enterTestGroupDescription(self, ctx:FuncTestCaseParser.TestGroupDescriptionContext): + def enterTestGroupDescription( + self, ctx: FuncTestCaseParser.TestGroupDescriptionContext + ): pass # Exit a parse tree produced by FuncTestCaseParser#testGroupDescription. - def exitTestGroupDescription(self, ctx:FuncTestCaseParser.TestGroupDescriptionContext): + def exitTestGroupDescription( + self, ctx: FuncTestCaseParser.TestGroupDescriptionContext + ): pass - # Enter a parse tree produced by FuncTestCaseParser#testCase. - def enterTestCase(self, ctx:FuncTestCaseParser.TestCaseContext): + def enterTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): pass # Exit a parse tree produced by FuncTestCaseParser#testCase. - def exitTestCase(self, ctx:FuncTestCaseParser.TestCaseContext): + def exitTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): pass - # Enter a parse tree produced by FuncTestCaseParser#testGroup. - def enterTestGroup(self, ctx:FuncTestCaseParser.TestGroupContext): + def enterTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): pass # Exit a parse tree produced by FuncTestCaseParser#testGroup. - def exitTestGroup(self, ctx:FuncTestCaseParser.TestGroupContext): + def exitTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): pass - # Enter a parse tree produced by FuncTestCaseParser#arguments. - def enterArguments(self, ctx:FuncTestCaseParser.ArgumentsContext): + def enterArguments(self, ctx: FuncTestCaseParser.ArgumentsContext): pass # Exit a parse tree produced by FuncTestCaseParser#arguments. - def exitArguments(self, ctx:FuncTestCaseParser.ArgumentsContext): + def exitArguments(self, ctx: FuncTestCaseParser.ArgumentsContext): pass - # Enter a parse tree produced by FuncTestCaseParser#result. - def enterResult(self, ctx:FuncTestCaseParser.ResultContext): + def enterResult(self, ctx: FuncTestCaseParser.ResultContext): pass # Exit a parse tree produced by FuncTestCaseParser#result. - def exitResult(self, ctx:FuncTestCaseParser.ResultContext): + def exitResult(self, ctx: FuncTestCaseParser.ResultContext): pass - # Enter a parse tree produced by FuncTestCaseParser#argument. - def enterArgument(self, ctx:FuncTestCaseParser.ArgumentContext): + def enterArgument(self, ctx: FuncTestCaseParser.ArgumentContext): pass # Exit a parse tree produced by FuncTestCaseParser#argument. - def exitArgument(self, ctx:FuncTestCaseParser.ArgumentContext): + def exitArgument(self, ctx: FuncTestCaseParser.ArgumentContext): pass - # Enter a parse tree produced by FuncTestCaseParser#numericLiteral. - def enterNumericLiteral(self, ctx:FuncTestCaseParser.NumericLiteralContext): + def enterNumericLiteral(self, ctx: FuncTestCaseParser.NumericLiteralContext): pass # Exit a parse tree produced by FuncTestCaseParser#numericLiteral. - def exitNumericLiteral(self, ctx:FuncTestCaseParser.NumericLiteralContext): + def exitNumericLiteral(self, ctx: FuncTestCaseParser.NumericLiteralContext): pass - # Enter a parse tree produced by FuncTestCaseParser#nullArg. - def enterNullArg(self, ctx:FuncTestCaseParser.NullArgContext): + def enterNullArg(self, ctx: FuncTestCaseParser.NullArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#nullArg. - def exitNullArg(self, ctx:FuncTestCaseParser.NullArgContext): + def exitNullArg(self, ctx: FuncTestCaseParser.NullArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#i8Arg. - def enterI8Arg(self, ctx:FuncTestCaseParser.I8ArgContext): + def enterI8Arg(self, ctx: FuncTestCaseParser.I8ArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#i8Arg. - def exitI8Arg(self, ctx:FuncTestCaseParser.I8ArgContext): + def exitI8Arg(self, ctx: FuncTestCaseParser.I8ArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#i16Arg. - def enterI16Arg(self, ctx:FuncTestCaseParser.I16ArgContext): + def enterI16Arg(self, ctx: FuncTestCaseParser.I16ArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#i16Arg. - def exitI16Arg(self, ctx:FuncTestCaseParser.I16ArgContext): + def exitI16Arg(self, ctx: FuncTestCaseParser.I16ArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#i32Arg. - def enterI32Arg(self, ctx:FuncTestCaseParser.I32ArgContext): + def enterI32Arg(self, ctx: FuncTestCaseParser.I32ArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#i32Arg. - def exitI32Arg(self, ctx:FuncTestCaseParser.I32ArgContext): + def exitI32Arg(self, ctx: FuncTestCaseParser.I32ArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#i64Arg. - def enterI64Arg(self, ctx:FuncTestCaseParser.I64ArgContext): + def enterI64Arg(self, ctx: FuncTestCaseParser.I64ArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#i64Arg. - def exitI64Arg(self, ctx:FuncTestCaseParser.I64ArgContext): + def exitI64Arg(self, ctx: FuncTestCaseParser.I64ArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#fp32Arg. - def enterFp32Arg(self, ctx:FuncTestCaseParser.Fp32ArgContext): + def enterFp32Arg(self, ctx: FuncTestCaseParser.Fp32ArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#fp32Arg. - def exitFp32Arg(self, ctx:FuncTestCaseParser.Fp32ArgContext): + def exitFp32Arg(self, ctx: FuncTestCaseParser.Fp32ArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#fp64Arg. - def enterFp64Arg(self, ctx:FuncTestCaseParser.Fp64ArgContext): + def enterFp64Arg(self, ctx: FuncTestCaseParser.Fp64ArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#fp64Arg. - def exitFp64Arg(self, ctx:FuncTestCaseParser.Fp64ArgContext): + def exitFp64Arg(self, ctx: FuncTestCaseParser.Fp64ArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#decimalArg. - def enterDecimalArg(self, ctx:FuncTestCaseParser.DecimalArgContext): + def enterDecimalArg(self, ctx: FuncTestCaseParser.DecimalArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#decimalArg. - def exitDecimalArg(self, ctx:FuncTestCaseParser.DecimalArgContext): + def exitDecimalArg(self, ctx: FuncTestCaseParser.DecimalArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#booleanArg. - def enterBooleanArg(self, ctx:FuncTestCaseParser.BooleanArgContext): + def enterBooleanArg(self, ctx: FuncTestCaseParser.BooleanArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#booleanArg. - def exitBooleanArg(self, ctx:FuncTestCaseParser.BooleanArgContext): + def exitBooleanArg(self, ctx: FuncTestCaseParser.BooleanArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#stringArg. - def enterStringArg(self, ctx:FuncTestCaseParser.StringArgContext): + def enterStringArg(self, ctx: FuncTestCaseParser.StringArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#stringArg. - def exitStringArg(self, ctx:FuncTestCaseParser.StringArgContext): + def exitStringArg(self, ctx: FuncTestCaseParser.StringArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#dateArg. - def enterDateArg(self, ctx:FuncTestCaseParser.DateArgContext): + def enterDateArg(self, ctx: FuncTestCaseParser.DateArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#dateArg. - def exitDateArg(self, ctx:FuncTestCaseParser.DateArgContext): + def exitDateArg(self, ctx: FuncTestCaseParser.DateArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#timeArg. - def enterTimeArg(self, ctx:FuncTestCaseParser.TimeArgContext): + def enterTimeArg(self, ctx: FuncTestCaseParser.TimeArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#timeArg. - def exitTimeArg(self, ctx:FuncTestCaseParser.TimeArgContext): + def exitTimeArg(self, ctx: FuncTestCaseParser.TimeArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#timestampArg. - def enterTimestampArg(self, ctx:FuncTestCaseParser.TimestampArgContext): + def enterTimestampArg(self, ctx: FuncTestCaseParser.TimestampArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#timestampArg. - def exitTimestampArg(self, ctx:FuncTestCaseParser.TimestampArgContext): + def exitTimestampArg(self, ctx: FuncTestCaseParser.TimestampArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#timestampTzArg. - def enterTimestampTzArg(self, ctx:FuncTestCaseParser.TimestampTzArgContext): + def enterTimestampTzArg(self, ctx: FuncTestCaseParser.TimestampTzArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#timestampTzArg. - def exitTimestampTzArg(self, ctx:FuncTestCaseParser.TimestampTzArgContext): + def exitTimestampTzArg(self, ctx: FuncTestCaseParser.TimestampTzArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#intervalYearArg. - def enterIntervalYearArg(self, ctx:FuncTestCaseParser.IntervalYearArgContext): + def enterIntervalYearArg(self, ctx: FuncTestCaseParser.IntervalYearArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#intervalYearArg. - def exitIntervalYearArg(self, ctx:FuncTestCaseParser.IntervalYearArgContext): + def exitIntervalYearArg(self, ctx: FuncTestCaseParser.IntervalYearArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#intervalDayArg. - def enterIntervalDayArg(self, ctx:FuncTestCaseParser.IntervalDayArgContext): + def enterIntervalDayArg(self, ctx: FuncTestCaseParser.IntervalDayArgContext): pass # Exit a parse tree produced by FuncTestCaseParser#intervalDayArg. - def exitIntervalDayArg(self, ctx:FuncTestCaseParser.IntervalDayArgContext): + def exitIntervalDayArg(self, ctx: FuncTestCaseParser.IntervalDayArgContext): pass - # Enter a parse tree produced by FuncTestCaseParser#intervalYearLiteral. - def enterIntervalYearLiteral(self, ctx:FuncTestCaseParser.IntervalYearLiteralContext): + def enterIntervalYearLiteral( + self, ctx: FuncTestCaseParser.IntervalYearLiteralContext + ): pass # Exit a parse tree produced by FuncTestCaseParser#intervalYearLiteral. - def exitIntervalYearLiteral(self, ctx:FuncTestCaseParser.IntervalYearLiteralContext): + def exitIntervalYearLiteral( + self, ctx: FuncTestCaseParser.IntervalYearLiteralContext + ): pass - # Enter a parse tree produced by FuncTestCaseParser#intervalDayLiteral. - def enterIntervalDayLiteral(self, ctx:FuncTestCaseParser.IntervalDayLiteralContext): + def enterIntervalDayLiteral( + self, ctx: FuncTestCaseParser.IntervalDayLiteralContext + ): pass # Exit a parse tree produced by FuncTestCaseParser#intervalDayLiteral. - def exitIntervalDayLiteral(self, ctx:FuncTestCaseParser.IntervalDayLiteralContext): + def exitIntervalDayLiteral(self, ctx: FuncTestCaseParser.IntervalDayLiteralContext): pass - # Enter a parse tree produced by FuncTestCaseParser#timeInterval. - def enterTimeInterval(self, ctx:FuncTestCaseParser.TimeIntervalContext): + def enterTimeInterval(self, ctx: FuncTestCaseParser.TimeIntervalContext): pass # Exit a parse tree produced by FuncTestCaseParser#timeInterval. - def exitTimeInterval(self, ctx:FuncTestCaseParser.TimeIntervalContext): + def exitTimeInterval(self, ctx: FuncTestCaseParser.TimeIntervalContext): pass - # Enter a parse tree produced by FuncTestCaseParser#datatype. - def enterDatatype(self, ctx:FuncTestCaseParser.DatatypeContext): + def enterDatatype(self, ctx: FuncTestCaseParser.DatatypeContext): pass # Exit a parse tree produced by FuncTestCaseParser#datatype. - def exitDatatype(self, ctx:FuncTestCaseParser.DatatypeContext): + def exitDatatype(self, ctx: FuncTestCaseParser.DatatypeContext): pass - # Enter a parse tree produced by FuncTestCaseParser#Boolean. - def enterBoolean(self, ctx:FuncTestCaseParser.BooleanContext): + def enterBoolean(self, ctx: FuncTestCaseParser.BooleanContext): pass # Exit a parse tree produced by FuncTestCaseParser#Boolean. - def exitBoolean(self, ctx:FuncTestCaseParser.BooleanContext): + def exitBoolean(self, ctx: FuncTestCaseParser.BooleanContext): pass - # Enter a parse tree produced by FuncTestCaseParser#i8. - def enterI8(self, ctx:FuncTestCaseParser.I8Context): + def enterI8(self, ctx: FuncTestCaseParser.I8Context): pass # Exit a parse tree produced by FuncTestCaseParser#i8. - def exitI8(self, ctx:FuncTestCaseParser.I8Context): + def exitI8(self, ctx: FuncTestCaseParser.I8Context): pass - # Enter a parse tree produced by FuncTestCaseParser#i16. - def enterI16(self, ctx:FuncTestCaseParser.I16Context): + def enterI16(self, ctx: FuncTestCaseParser.I16Context): pass # Exit a parse tree produced by FuncTestCaseParser#i16. - def exitI16(self, ctx:FuncTestCaseParser.I16Context): + def exitI16(self, ctx: FuncTestCaseParser.I16Context): pass - # Enter a parse tree produced by FuncTestCaseParser#i32. - def enterI32(self, ctx:FuncTestCaseParser.I32Context): + def enterI32(self, ctx: FuncTestCaseParser.I32Context): pass # Exit a parse tree produced by FuncTestCaseParser#i32. - def exitI32(self, ctx:FuncTestCaseParser.I32Context): + def exitI32(self, ctx: FuncTestCaseParser.I32Context): pass - # Enter a parse tree produced by FuncTestCaseParser#i64. - def enterI64(self, ctx:FuncTestCaseParser.I64Context): + def enterI64(self, ctx: FuncTestCaseParser.I64Context): pass # Exit a parse tree produced by FuncTestCaseParser#i64. - def exitI64(self, ctx:FuncTestCaseParser.I64Context): + def exitI64(self, ctx: FuncTestCaseParser.I64Context): pass - # Enter a parse tree produced by FuncTestCaseParser#fp32. - def enterFp32(self, ctx:FuncTestCaseParser.Fp32Context): + def enterFp32(self, ctx: FuncTestCaseParser.Fp32Context): pass # Exit a parse tree produced by FuncTestCaseParser#fp32. - def exitFp32(self, ctx:FuncTestCaseParser.Fp32Context): + def exitFp32(self, ctx: FuncTestCaseParser.Fp32Context): pass - # Enter a parse tree produced by FuncTestCaseParser#fp64. - def enterFp64(self, ctx:FuncTestCaseParser.Fp64Context): + def enterFp64(self, ctx: FuncTestCaseParser.Fp64Context): pass # Exit a parse tree produced by FuncTestCaseParser#fp64. - def exitFp64(self, ctx:FuncTestCaseParser.Fp64Context): + def exitFp64(self, ctx: FuncTestCaseParser.Fp64Context): pass - # Enter a parse tree produced by FuncTestCaseParser#string. - def enterString(self, ctx:FuncTestCaseParser.StringContext): + def enterString(self, ctx: FuncTestCaseParser.StringContext): pass # Exit a parse tree produced by FuncTestCaseParser#string. - def exitString(self, ctx:FuncTestCaseParser.StringContext): + def exitString(self, ctx: FuncTestCaseParser.StringContext): pass - # Enter a parse tree produced by FuncTestCaseParser#binary. - def enterBinary(self, ctx:FuncTestCaseParser.BinaryContext): + def enterBinary(self, ctx: FuncTestCaseParser.BinaryContext): pass # Exit a parse tree produced by FuncTestCaseParser#binary. - def exitBinary(self, ctx:FuncTestCaseParser.BinaryContext): + def exitBinary(self, ctx: FuncTestCaseParser.BinaryContext): pass - # Enter a parse tree produced by FuncTestCaseParser#timestamp. - def enterTimestamp(self, ctx:FuncTestCaseParser.TimestampContext): + def enterTimestamp(self, ctx: FuncTestCaseParser.TimestampContext): pass # Exit a parse tree produced by FuncTestCaseParser#timestamp. - def exitTimestamp(self, ctx:FuncTestCaseParser.TimestampContext): + def exitTimestamp(self, ctx: FuncTestCaseParser.TimestampContext): pass - # Enter a parse tree produced by FuncTestCaseParser#timestampTz. - def enterTimestampTz(self, ctx:FuncTestCaseParser.TimestampTzContext): + def enterTimestampTz(self, ctx: FuncTestCaseParser.TimestampTzContext): pass # Exit a parse tree produced by FuncTestCaseParser#timestampTz. - def exitTimestampTz(self, ctx:FuncTestCaseParser.TimestampTzContext): + def exitTimestampTz(self, ctx: FuncTestCaseParser.TimestampTzContext): pass - # Enter a parse tree produced by FuncTestCaseParser#date. - def enterDate(self, ctx:FuncTestCaseParser.DateContext): + def enterDate(self, ctx: FuncTestCaseParser.DateContext): pass # Exit a parse tree produced by FuncTestCaseParser#date. - def exitDate(self, ctx:FuncTestCaseParser.DateContext): + def exitDate(self, ctx: FuncTestCaseParser.DateContext): pass - # Enter a parse tree produced by FuncTestCaseParser#time. - def enterTime(self, ctx:FuncTestCaseParser.TimeContext): + def enterTime(self, ctx: FuncTestCaseParser.TimeContext): pass # Exit a parse tree produced by FuncTestCaseParser#time. - def exitTime(self, ctx:FuncTestCaseParser.TimeContext): + def exitTime(self, ctx: FuncTestCaseParser.TimeContext): pass - # Enter a parse tree produced by FuncTestCaseParser#intervalDay. - def enterIntervalDay(self, ctx:FuncTestCaseParser.IntervalDayContext): + def enterIntervalDay(self, ctx: FuncTestCaseParser.IntervalDayContext): pass # Exit a parse tree produced by FuncTestCaseParser#intervalDay. - def exitIntervalDay(self, ctx:FuncTestCaseParser.IntervalDayContext): + def exitIntervalDay(self, ctx: FuncTestCaseParser.IntervalDayContext): pass - # Enter a parse tree produced by FuncTestCaseParser#intervalYear. - def enterIntervalYear(self, ctx:FuncTestCaseParser.IntervalYearContext): + def enterIntervalYear(self, ctx: FuncTestCaseParser.IntervalYearContext): pass # Exit a parse tree produced by FuncTestCaseParser#intervalYear. - def exitIntervalYear(self, ctx:FuncTestCaseParser.IntervalYearContext): + def exitIntervalYear(self, ctx: FuncTestCaseParser.IntervalYearContext): pass - # Enter a parse tree produced by FuncTestCaseParser#uuid. - def enterUuid(self, ctx:FuncTestCaseParser.UuidContext): + def enterUuid(self, ctx: FuncTestCaseParser.UuidContext): pass # Exit a parse tree produced by FuncTestCaseParser#uuid. - def exitUuid(self, ctx:FuncTestCaseParser.UuidContext): + def exitUuid(self, ctx: FuncTestCaseParser.UuidContext): pass - # Enter a parse tree produced by FuncTestCaseParser#userDefined. - def enterUserDefined(self, ctx:FuncTestCaseParser.UserDefinedContext): + def enterUserDefined(self, ctx: FuncTestCaseParser.UserDefinedContext): pass # Exit a parse tree produced by FuncTestCaseParser#userDefined. - def exitUserDefined(self, ctx:FuncTestCaseParser.UserDefinedContext): + def exitUserDefined(self, ctx: FuncTestCaseParser.UserDefinedContext): pass - # Enter a parse tree produced by FuncTestCaseParser#fixedChar. - def enterFixedChar(self, ctx:FuncTestCaseParser.FixedCharContext): + def enterFixedChar(self, ctx: FuncTestCaseParser.FixedCharContext): pass # Exit a parse tree produced by FuncTestCaseParser#fixedChar. - def exitFixedChar(self, ctx:FuncTestCaseParser.FixedCharContext): + def exitFixedChar(self, ctx: FuncTestCaseParser.FixedCharContext): pass - # Enter a parse tree produced by FuncTestCaseParser#varChar. - def enterVarChar(self, ctx:FuncTestCaseParser.VarCharContext): + def enterVarChar(self, ctx: FuncTestCaseParser.VarCharContext): pass # Exit a parse tree produced by FuncTestCaseParser#varChar. - def exitVarChar(self, ctx:FuncTestCaseParser.VarCharContext): + def exitVarChar(self, ctx: FuncTestCaseParser.VarCharContext): pass - # Enter a parse tree produced by FuncTestCaseParser#fixedBinary. - def enterFixedBinary(self, ctx:FuncTestCaseParser.FixedBinaryContext): + def enterFixedBinary(self, ctx: FuncTestCaseParser.FixedBinaryContext): pass # Exit a parse tree produced by FuncTestCaseParser#fixedBinary. - def exitFixedBinary(self, ctx:FuncTestCaseParser.FixedBinaryContext): + def exitFixedBinary(self, ctx: FuncTestCaseParser.FixedBinaryContext): pass - # Enter a parse tree produced by FuncTestCaseParser#decimal. - def enterDecimal(self, ctx:FuncTestCaseParser.DecimalContext): + def enterDecimal(self, ctx: FuncTestCaseParser.DecimalContext): pass # Exit a parse tree produced by FuncTestCaseParser#decimal. - def exitDecimal(self, ctx:FuncTestCaseParser.DecimalContext): + def exitDecimal(self, ctx: FuncTestCaseParser.DecimalContext): pass - # Enter a parse tree produced by FuncTestCaseParser#precisionTimestamp. - def enterPrecisionTimestamp(self, ctx:FuncTestCaseParser.PrecisionTimestampContext): + def enterPrecisionTimestamp( + self, ctx: FuncTestCaseParser.PrecisionTimestampContext + ): pass # Exit a parse tree produced by FuncTestCaseParser#precisionTimestamp. - def exitPrecisionTimestamp(self, ctx:FuncTestCaseParser.PrecisionTimestampContext): + def exitPrecisionTimestamp(self, ctx: FuncTestCaseParser.PrecisionTimestampContext): pass - # Enter a parse tree produced by FuncTestCaseParser#precisionTimestampTZ. - def enterPrecisionTimestampTZ(self, ctx:FuncTestCaseParser.PrecisionTimestampTZContext): + def enterPrecisionTimestampTZ( + self, ctx: FuncTestCaseParser.PrecisionTimestampTZContext + ): pass # Exit a parse tree produced by FuncTestCaseParser#precisionTimestampTZ. - def exitPrecisionTimestampTZ(self, ctx:FuncTestCaseParser.PrecisionTimestampTZContext): + def exitPrecisionTimestampTZ( + self, ctx: FuncTestCaseParser.PrecisionTimestampTZContext + ): pass - # Enter a parse tree produced by FuncTestCaseParser#parameterizedType. - def enterParameterizedType(self, ctx:FuncTestCaseParser.ParameterizedTypeContext): + def enterParameterizedType(self, ctx: FuncTestCaseParser.ParameterizedTypeContext): pass # Exit a parse tree produced by FuncTestCaseParser#parameterizedType. - def exitParameterizedType(self, ctx:FuncTestCaseParser.ParameterizedTypeContext): + def exitParameterizedType(self, ctx: FuncTestCaseParser.ParameterizedTypeContext): pass - # Enter a parse tree produced by FuncTestCaseParser#integerLiteral. - def enterIntegerLiteral(self, ctx:FuncTestCaseParser.IntegerLiteralContext): + def enterIntegerLiteral(self, ctx: FuncTestCaseParser.IntegerLiteralContext): pass # Exit a parse tree produced by FuncTestCaseParser#integerLiteral. - def exitIntegerLiteral(self, ctx:FuncTestCaseParser.IntegerLiteralContext): + def exitIntegerLiteral(self, ctx: FuncTestCaseParser.IntegerLiteralContext): pass - # Enter a parse tree produced by FuncTestCaseParser#substraitError. - def enterSubstraitError(self, ctx:FuncTestCaseParser.SubstraitErrorContext): + def enterSubstraitError(self, ctx: FuncTestCaseParser.SubstraitErrorContext): pass # Exit a parse tree produced by FuncTestCaseParser#substraitError. - def exitSubstraitError(self, ctx:FuncTestCaseParser.SubstraitErrorContext): + def exitSubstraitError(self, ctx: FuncTestCaseParser.SubstraitErrorContext): pass - # Enter a parse tree produced by FuncTestCaseParser#func_option. - def enterFunc_option(self, ctx:FuncTestCaseParser.Func_optionContext): + def enterFunc_option(self, ctx: FuncTestCaseParser.Func_optionContext): pass # Exit a parse tree produced by FuncTestCaseParser#func_option. - def exitFunc_option(self, ctx:FuncTestCaseParser.Func_optionContext): + def exitFunc_option(self, ctx: FuncTestCaseParser.Func_optionContext): pass - # Enter a parse tree produced by FuncTestCaseParser#option_name. - def enterOption_name(self, ctx:FuncTestCaseParser.Option_nameContext): + def enterOption_name(self, ctx: FuncTestCaseParser.Option_nameContext): pass # Exit a parse tree produced by FuncTestCaseParser#option_name. - def exitOption_name(self, ctx:FuncTestCaseParser.Option_nameContext): + def exitOption_name(self, ctx: FuncTestCaseParser.Option_nameContext): pass - # Enter a parse tree produced by FuncTestCaseParser#option_value. - def enterOption_value(self, ctx:FuncTestCaseParser.Option_valueContext): + def enterOption_value(self, ctx: FuncTestCaseParser.Option_valueContext): pass # Exit a parse tree produced by FuncTestCaseParser#option_value. - def exitOption_value(self, ctx:FuncTestCaseParser.Option_valueContext): + def exitOption_value(self, ctx: FuncTestCaseParser.Option_valueContext): pass - # Enter a parse tree produced by FuncTestCaseParser#func_options. - def enterFunc_options(self, ctx:FuncTestCaseParser.Func_optionsContext): + def enterFunc_options(self, ctx: FuncTestCaseParser.Func_optionsContext): pass # Exit a parse tree produced by FuncTestCaseParser#func_options. - def exitFunc_options(self, ctx:FuncTestCaseParser.Func_optionsContext): + def exitFunc_options(self, ctx: FuncTestCaseParser.Func_optionsContext): pass - -del FuncTestCaseParser \ No newline at end of file +del FuncTestCaseParser diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py index d27e03d66..062450e8a 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py @@ -1,5 +1,6 @@ # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 from antlr4 import * + if "." in __name__: from .FuncTestCaseParser import FuncTestCaseParser else: @@ -7,312 +8,262 @@ # This class defines a complete generic visitor for a parse tree produced by FuncTestCaseParser. + class FuncTestCaseParserVisitor(ParseTreeVisitor): # Visit a parse tree produced by FuncTestCaseParser#doc. - def visitDoc(self, ctx:FuncTestCaseParser.DocContext): + def visitDoc(self, ctx: FuncTestCaseParser.DocContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#header. - def visitHeader(self, ctx:FuncTestCaseParser.HeaderContext): + def visitHeader(self, ctx: FuncTestCaseParser.HeaderContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#version. - def visitVersion(self, ctx:FuncTestCaseParser.VersionContext): + def visitVersion(self, ctx: FuncTestCaseParser.VersionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#include. - def visitInclude(self, ctx:FuncTestCaseParser.IncludeContext): + def visitInclude(self, ctx: FuncTestCaseParser.IncludeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#testGroupDescription. - def visitTestGroupDescription(self, ctx:FuncTestCaseParser.TestGroupDescriptionContext): + def visitTestGroupDescription( + self, ctx: FuncTestCaseParser.TestGroupDescriptionContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#testCase. - def visitTestCase(self, ctx:FuncTestCaseParser.TestCaseContext): + def visitTestCase(self, ctx: FuncTestCaseParser.TestCaseContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#testGroup. - def visitTestGroup(self, ctx:FuncTestCaseParser.TestGroupContext): + def visitTestGroup(self, ctx: FuncTestCaseParser.TestGroupContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#arguments. - def visitArguments(self, ctx:FuncTestCaseParser.ArgumentsContext): + def visitArguments(self, ctx: FuncTestCaseParser.ArgumentsContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#result. - def visitResult(self, ctx:FuncTestCaseParser.ResultContext): + def visitResult(self, ctx: FuncTestCaseParser.ResultContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#argument. - def visitArgument(self, ctx:FuncTestCaseParser.ArgumentContext): + def visitArgument(self, ctx: FuncTestCaseParser.ArgumentContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#numericLiteral. - def visitNumericLiteral(self, ctx:FuncTestCaseParser.NumericLiteralContext): + def visitNumericLiteral(self, ctx: FuncTestCaseParser.NumericLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#nullArg. - def visitNullArg(self, ctx:FuncTestCaseParser.NullArgContext): + def visitNullArg(self, ctx: FuncTestCaseParser.NullArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i8Arg. - def visitI8Arg(self, ctx:FuncTestCaseParser.I8ArgContext): + def visitI8Arg(self, ctx: FuncTestCaseParser.I8ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i16Arg. - def visitI16Arg(self, ctx:FuncTestCaseParser.I16ArgContext): + def visitI16Arg(self, ctx: FuncTestCaseParser.I16ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i32Arg. - def visitI32Arg(self, ctx:FuncTestCaseParser.I32ArgContext): + def visitI32Arg(self, ctx: FuncTestCaseParser.I32ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i64Arg. - def visitI64Arg(self, ctx:FuncTestCaseParser.I64ArgContext): + def visitI64Arg(self, ctx: FuncTestCaseParser.I64ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#fp32Arg. - def visitFp32Arg(self, ctx:FuncTestCaseParser.Fp32ArgContext): + def visitFp32Arg(self, ctx: FuncTestCaseParser.Fp32ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#fp64Arg. - def visitFp64Arg(self, ctx:FuncTestCaseParser.Fp64ArgContext): + def visitFp64Arg(self, ctx: FuncTestCaseParser.Fp64ArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#decimalArg. - def visitDecimalArg(self, ctx:FuncTestCaseParser.DecimalArgContext): + def visitDecimalArg(self, ctx: FuncTestCaseParser.DecimalArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#booleanArg. - def visitBooleanArg(self, ctx:FuncTestCaseParser.BooleanArgContext): + def visitBooleanArg(self, ctx: FuncTestCaseParser.BooleanArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#stringArg. - def visitStringArg(self, ctx:FuncTestCaseParser.StringArgContext): + def visitStringArg(self, ctx: FuncTestCaseParser.StringArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#dateArg. - def visitDateArg(self, ctx:FuncTestCaseParser.DateArgContext): + def visitDateArg(self, ctx: FuncTestCaseParser.DateArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#timeArg. - def visitTimeArg(self, ctx:FuncTestCaseParser.TimeArgContext): + def visitTimeArg(self, ctx: FuncTestCaseParser.TimeArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#timestampArg. - def visitTimestampArg(self, ctx:FuncTestCaseParser.TimestampArgContext): + def visitTimestampArg(self, ctx: FuncTestCaseParser.TimestampArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#timestampTzArg. - def visitTimestampTzArg(self, ctx:FuncTestCaseParser.TimestampTzArgContext): + def visitTimestampTzArg(self, ctx: FuncTestCaseParser.TimestampTzArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#intervalYearArg. - def visitIntervalYearArg(self, ctx:FuncTestCaseParser.IntervalYearArgContext): + def visitIntervalYearArg(self, ctx: FuncTestCaseParser.IntervalYearArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#intervalDayArg. - def visitIntervalDayArg(self, ctx:FuncTestCaseParser.IntervalDayArgContext): + def visitIntervalDayArg(self, ctx: FuncTestCaseParser.IntervalDayArgContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#intervalYearLiteral. - def visitIntervalYearLiteral(self, ctx:FuncTestCaseParser.IntervalYearLiteralContext): + def visitIntervalYearLiteral( + self, ctx: FuncTestCaseParser.IntervalYearLiteralContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#intervalDayLiteral. - def visitIntervalDayLiteral(self, ctx:FuncTestCaseParser.IntervalDayLiteralContext): + def visitIntervalDayLiteral( + self, ctx: FuncTestCaseParser.IntervalDayLiteralContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#timeInterval. - def visitTimeInterval(self, ctx:FuncTestCaseParser.TimeIntervalContext): + def visitTimeInterval(self, ctx: FuncTestCaseParser.TimeIntervalContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#datatype. - def visitDatatype(self, ctx:FuncTestCaseParser.DatatypeContext): + def visitDatatype(self, ctx: FuncTestCaseParser.DatatypeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#Boolean. - def visitBoolean(self, ctx:FuncTestCaseParser.BooleanContext): + def visitBoolean(self, ctx: FuncTestCaseParser.BooleanContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i8. - def visitI8(self, ctx:FuncTestCaseParser.I8Context): + def visitI8(self, ctx: FuncTestCaseParser.I8Context): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i16. - def visitI16(self, ctx:FuncTestCaseParser.I16Context): + def visitI16(self, ctx: FuncTestCaseParser.I16Context): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i32. - def visitI32(self, ctx:FuncTestCaseParser.I32Context): + def visitI32(self, ctx: FuncTestCaseParser.I32Context): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#i64. - def visitI64(self, ctx:FuncTestCaseParser.I64Context): + def visitI64(self, ctx: FuncTestCaseParser.I64Context): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#fp32. - def visitFp32(self, ctx:FuncTestCaseParser.Fp32Context): + def visitFp32(self, ctx: FuncTestCaseParser.Fp32Context): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#fp64. - def visitFp64(self, ctx:FuncTestCaseParser.Fp64Context): + def visitFp64(self, ctx: FuncTestCaseParser.Fp64Context): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#string. - def visitString(self, ctx:FuncTestCaseParser.StringContext): + def visitString(self, ctx: FuncTestCaseParser.StringContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#binary. - def visitBinary(self, ctx:FuncTestCaseParser.BinaryContext): + def visitBinary(self, ctx: FuncTestCaseParser.BinaryContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#timestamp. - def visitTimestamp(self, ctx:FuncTestCaseParser.TimestampContext): + def visitTimestamp(self, ctx: FuncTestCaseParser.TimestampContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#timestampTz. - def visitTimestampTz(self, ctx:FuncTestCaseParser.TimestampTzContext): + def visitTimestampTz(self, ctx: FuncTestCaseParser.TimestampTzContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#date. - def visitDate(self, ctx:FuncTestCaseParser.DateContext): + def visitDate(self, ctx: FuncTestCaseParser.DateContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#time. - def visitTime(self, ctx:FuncTestCaseParser.TimeContext): + def visitTime(self, ctx: FuncTestCaseParser.TimeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#intervalDay. - def visitIntervalDay(self, ctx:FuncTestCaseParser.IntervalDayContext): + def visitIntervalDay(self, ctx: FuncTestCaseParser.IntervalDayContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#intervalYear. - def visitIntervalYear(self, ctx:FuncTestCaseParser.IntervalYearContext): + def visitIntervalYear(self, ctx: FuncTestCaseParser.IntervalYearContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#uuid. - def visitUuid(self, ctx:FuncTestCaseParser.UuidContext): + def visitUuid(self, ctx: FuncTestCaseParser.UuidContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#userDefined. - def visitUserDefined(self, ctx:FuncTestCaseParser.UserDefinedContext): + def visitUserDefined(self, ctx: FuncTestCaseParser.UserDefinedContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#fixedChar. - def visitFixedChar(self, ctx:FuncTestCaseParser.FixedCharContext): + def visitFixedChar(self, ctx: FuncTestCaseParser.FixedCharContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#varChar. - def visitVarChar(self, ctx:FuncTestCaseParser.VarCharContext): + def visitVarChar(self, ctx: FuncTestCaseParser.VarCharContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#fixedBinary. - def visitFixedBinary(self, ctx:FuncTestCaseParser.FixedBinaryContext): + def visitFixedBinary(self, ctx: FuncTestCaseParser.FixedBinaryContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#decimal. - def visitDecimal(self, ctx:FuncTestCaseParser.DecimalContext): + def visitDecimal(self, ctx: FuncTestCaseParser.DecimalContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#precisionTimestamp. - def visitPrecisionTimestamp(self, ctx:FuncTestCaseParser.PrecisionTimestampContext): + def visitPrecisionTimestamp( + self, ctx: FuncTestCaseParser.PrecisionTimestampContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#precisionTimestampTZ. - def visitPrecisionTimestampTZ(self, ctx:FuncTestCaseParser.PrecisionTimestampTZContext): + def visitPrecisionTimestampTZ( + self, ctx: FuncTestCaseParser.PrecisionTimestampTZContext + ): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#parameterizedType. - def visitParameterizedType(self, ctx:FuncTestCaseParser.ParameterizedTypeContext): + def visitParameterizedType(self, ctx: FuncTestCaseParser.ParameterizedTypeContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#integerLiteral. - def visitIntegerLiteral(self, ctx:FuncTestCaseParser.IntegerLiteralContext): + def visitIntegerLiteral(self, ctx: FuncTestCaseParser.IntegerLiteralContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#substraitError. - def visitSubstraitError(self, ctx:FuncTestCaseParser.SubstraitErrorContext): + def visitSubstraitError(self, ctx: FuncTestCaseParser.SubstraitErrorContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#func_option. - def visitFunc_option(self, ctx:FuncTestCaseParser.Func_optionContext): + def visitFunc_option(self, ctx: FuncTestCaseParser.Func_optionContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#option_name. - def visitOption_name(self, ctx:FuncTestCaseParser.Option_nameContext): + def visitOption_name(self, ctx: FuncTestCaseParser.Option_nameContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#option_value. - def visitOption_value(self, ctx:FuncTestCaseParser.Option_valueContext): + def visitOption_value(self, ctx: FuncTestCaseParser.Option_valueContext): return self.visitChildren(ctx) - # Visit a parse tree produced by FuncTestCaseParser#func_options. - def visitFunc_options(self, ctx:FuncTestCaseParser.Func_optionsContext): + def visitFunc_options(self, ctx: FuncTestCaseParser.Func_optionsContext): return self.visitChildren(ctx) - -del FuncTestCaseParser \ No newline at end of file +del FuncTestCaseParser diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py index fad7b27f0..0b426603e 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.py +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -2,6 +2,7 @@ from antlr4 import * from io import StringIO import sys + if sys.version_info[1] > 5: from typing import TextIO else: @@ -10,234 +11,5353 @@ def serializedATN(): return [ - 4,0,62,630,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5, - 2,6,7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2, - 13,7,13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7, - 19,2,20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2, - 26,7,26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7, - 32,2,33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2, - 39,7,39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7, - 45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2, - 52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7, - 58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2, - 65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7, - 71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2, - 78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7, - 84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,1,0,1,0,1,0, - 1,0,5,0,186,8,0,10,0,12,0,189,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,4, - 1,198,8,1,11,1,12,1,199,1,1,3,1,203,8,1,1,1,5,1,206,8,1,10,1,12, - 1,209,9,1,1,1,1,1,1,1,1,1,1,1,1,2,4,2,217,8,2,11,2,12,2,218,1,2, - 1,2,1,3,1,3,1,4,1,4,1,5,1,5,1,6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10, - 1,10,1,11,1,11,1,12,1,12,1,13,1,13,1,14,1,14,1,15,1,15,1,16,1,16, - 1,17,1,17,1,18,1,18,1,19,1,19,1,20,1,20,1,21,1,21,1,22,1,22,1,23, - 1,23,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27,1,28,1,28,1,29,1,29, - 1,30,1,30,1,30,5,30,280,8,30,10,30,12,30,283,9,30,3,30,285,8,30, - 1,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32,1,33,1,33,1,33,1,33,1,33, - 1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,35,1,35,1,35,1,36,1,36, - 1,36,1,36,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,39,1,39,1,39, - 1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41, - 1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43, - 1,43,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44, - 1,44,1,44,1,44,1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,46,1,46,1,46, - 1,46,1,46,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,47, - 1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48,1,48, - 1,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,1,50,1,50,1,50,1,50,1,50, - 1,50,1,50,1,50,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51, - 1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,52,1,52,1,52, - 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52, - 1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53, - 1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,54,1,55, - 1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,55,1,56,1,56, - 1,56,1,56,1,56,1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57, - 1,58,1,58,1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60, - 1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,63, - 1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,65, - 1,66,1,66,1,66,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68, - 1,68,1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,71,1,71,1,71, - 1,71,1,72,1,72,1,72,1,72,1,72,1,72,1,73,1,73,1,73,1,73,1,73,1,73, - 1,74,1,74,1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,76,1,76, - 1,76,1,77,1,77,5,77,602,8,77,10,77,12,77,605,9,77,1,78,1,78,1,79, - 1,79,1,80,1,80,1,81,1,81,1,82,1,82,1,83,1,83,1,84,1,84,1,85,1,85, - 1,86,1,86,1,87,1,87,1,88,1,88,1,89,1,89,0,0,90,1,1,3,2,5,3,7,0,9, - 0,11,0,13,0,15,0,17,0,19,0,21,0,23,0,25,0,27,0,29,0,31,0,33,0,35, - 0,37,0,39,0,41,0,43,0,45,0,47,0,49,0,51,0,53,0,55,0,57,0,59,0,61, - 0,63,4,65,5,67,6,69,7,71,8,73,9,75,10,77,11,79,12,81,13,83,14,85, - 15,87,16,89,17,91,18,93,19,95,20,97,21,99,22,101,23,103,24,105,25, - 107,26,109,27,111,28,113,29,115,30,117,31,119,32,121,33,123,34,125, - 35,127,36,129,37,131,38,133,39,135,40,137,41,139,42,141,43,143,44, - 145,45,147,46,149,47,151,48,153,49,155,50,157,51,159,52,161,53,163, - 54,165,55,167,56,169,57,171,58,173,59,175,60,177,61,179,62,1,0,34, - 2,0,10,10,13,13,1,0,42,42,2,0,42,42,47,47,3,0,9,10,13,13,32,32,2, - 0,65,65,97,97,2,0,66,66,98,98,2,0,67,67,99,99,2,0,68,68,100,100, - 2,0,69,69,101,101,2,0,70,70,102,102,2,0,71,71,103,103,2,0,72,72, - 104,104,2,0,73,73,105,105,2,0,74,74,106,106,2,0,75,75,107,107,2, - 0,76,76,108,108,2,0,77,77,109,109,2,0,78,78,110,110,2,0,79,79,111, - 111,2,0,80,80,112,112,2,0,81,81,113,113,2,0,82,82,114,114,2,0,83, - 83,115,115,2,0,84,84,116,116,2,0,85,85,117,117,2,0,86,86,118,118, - 2,0,87,87,119,119,2,0,88,88,120,120,2,0,89,89,121,121,2,0,90,90, - 122,122,1,0,48,57,1,0,49,57,3,0,65,90,95,95,97,122,4,0,48,57,65, - 90,95,95,97,122,609,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,63,1,0, - 0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0, - 0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0, - 0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0, - 0,0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1, - 0,0,0,0,105,1,0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0, - 113,1,0,0,0,0,115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0, - 0,0,0,123,1,0,0,0,0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131, - 1,0,0,0,0,133,1,0,0,0,0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0, - 0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0,147,1,0,0,0,0,149,1, - 0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0,157,1,0,0,0,0, - 159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0,167,1,0, - 0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0,177, - 1,0,0,0,0,179,1,0,0,0,1,181,1,0,0,0,3,192,1,0,0,0,5,216,1,0,0,0, - 7,222,1,0,0,0,9,224,1,0,0,0,11,226,1,0,0,0,13,228,1,0,0,0,15,230, - 1,0,0,0,17,232,1,0,0,0,19,234,1,0,0,0,21,236,1,0,0,0,23,238,1,0, - 0,0,25,240,1,0,0,0,27,242,1,0,0,0,29,244,1,0,0,0,31,246,1,0,0,0, - 33,248,1,0,0,0,35,250,1,0,0,0,37,252,1,0,0,0,39,254,1,0,0,0,41,256, - 1,0,0,0,43,258,1,0,0,0,45,260,1,0,0,0,47,262,1,0,0,0,49,264,1,0, - 0,0,51,266,1,0,0,0,53,268,1,0,0,0,55,270,1,0,0,0,57,272,1,0,0,0, - 59,274,1,0,0,0,61,284,1,0,0,0,63,286,1,0,0,0,65,289,1,0,0,0,67,294, - 1,0,0,0,69,299,1,0,0,0,71,307,1,0,0,0,73,310,1,0,0,0,75,314,1,0, - 0,0,77,318,1,0,0,0,79,322,1,0,0,0,81,327,1,0,0,0,83,332,1,0,0,0, - 85,339,1,0,0,0,87,346,1,0,0,0,89,356,1,0,0,0,91,369,1,0,0,0,93,374, - 1,0,0,0,95,379,1,0,0,0,97,393,1,0,0,0,99,406,1,0,0,0,101,411,1,0, - 0,0,103,419,1,0,0,0,105,439,1,0,0,0,107,462,1,0,0,0,109,472,1,0, - 0,0,111,480,1,0,0,0,113,492,1,0,0,0,115,499,1,0,0,0,117,507,1,0, - 0,0,119,512,1,0,0,0,121,516,1,0,0,0,123,520,1,0,0,0,125,523,1,0, - 0,0,127,532,1,0,0,0,129,537,1,0,0,0,131,541,1,0,0,0,133,546,1,0, - 0,0,135,549,1,0,0,0,137,554,1,0,0,0,139,560,1,0,0,0,141,565,1,0, - 0,0,143,569,1,0,0,0,145,573,1,0,0,0,147,579,1,0,0,0,149,585,1,0, - 0,0,151,591,1,0,0,0,153,596,1,0,0,0,155,599,1,0,0,0,157,606,1,0, - 0,0,159,608,1,0,0,0,161,610,1,0,0,0,163,612,1,0,0,0,165,614,1,0, - 0,0,167,616,1,0,0,0,169,618,1,0,0,0,171,620,1,0,0,0,173,622,1,0, - 0,0,175,624,1,0,0,0,177,626,1,0,0,0,179,628,1,0,0,0,181,182,5,47, - 0,0,182,183,5,47,0,0,183,187,1,0,0,0,184,186,8,0,0,0,185,184,1,0, - 0,0,186,189,1,0,0,0,187,185,1,0,0,0,187,188,1,0,0,0,188,190,1,0, - 0,0,189,187,1,0,0,0,190,191,6,0,0,0,191,2,1,0,0,0,192,193,5,47,0, - 0,193,194,5,42,0,0,194,202,1,0,0,0,195,203,8,1,0,0,196,198,5,42, - 0,0,197,196,1,0,0,0,198,199,1,0,0,0,199,197,1,0,0,0,199,200,1,0, - 0,0,200,201,1,0,0,0,201,203,8,2,0,0,202,195,1,0,0,0,202,197,1,0, - 0,0,203,207,1,0,0,0,204,206,5,42,0,0,205,204,1,0,0,0,206,209,1,0, - 0,0,207,205,1,0,0,0,207,208,1,0,0,0,208,210,1,0,0,0,209,207,1,0, - 0,0,210,211,5,42,0,0,211,212,5,47,0,0,212,213,1,0,0,0,213,214,6, - 1,0,0,214,4,1,0,0,0,215,217,7,3,0,0,216,215,1,0,0,0,217,218,1,0, - 0,0,218,216,1,0,0,0,218,219,1,0,0,0,219,220,1,0,0,0,220,221,6,2, - 0,0,221,6,1,0,0,0,222,223,7,4,0,0,223,8,1,0,0,0,224,225,7,5,0,0, - 225,10,1,0,0,0,226,227,7,6,0,0,227,12,1,0,0,0,228,229,7,7,0,0,229, - 14,1,0,0,0,230,231,7,8,0,0,231,16,1,0,0,0,232,233,7,9,0,0,233,18, - 1,0,0,0,234,235,7,10,0,0,235,20,1,0,0,0,236,237,7,11,0,0,237,22, - 1,0,0,0,238,239,7,12,0,0,239,24,1,0,0,0,240,241,7,13,0,0,241,26, - 1,0,0,0,242,243,7,14,0,0,243,28,1,0,0,0,244,245,7,15,0,0,245,30, - 1,0,0,0,246,247,7,16,0,0,247,32,1,0,0,0,248,249,7,17,0,0,249,34, - 1,0,0,0,250,251,7,18,0,0,251,36,1,0,0,0,252,253,7,19,0,0,253,38, - 1,0,0,0,254,255,7,20,0,0,255,40,1,0,0,0,256,257,7,21,0,0,257,42, - 1,0,0,0,258,259,7,22,0,0,259,44,1,0,0,0,260,261,7,23,0,0,261,46, - 1,0,0,0,262,263,7,24,0,0,263,48,1,0,0,0,264,265,7,25,0,0,265,50, - 1,0,0,0,266,267,7,26,0,0,267,52,1,0,0,0,268,269,7,27,0,0,269,54, - 1,0,0,0,270,271,7,28,0,0,271,56,1,0,0,0,272,273,7,29,0,0,273,58, - 1,0,0,0,274,275,7,30,0,0,275,60,1,0,0,0,276,285,5,48,0,0,277,281, - 7,31,0,0,278,280,7,30,0,0,279,278,1,0,0,0,280,283,1,0,0,0,281,279, - 1,0,0,0,281,282,1,0,0,0,282,285,1,0,0,0,283,281,1,0,0,0,284,276, - 1,0,0,0,284,277,1,0,0,0,285,62,1,0,0,0,286,287,3,23,11,0,287,288, - 3,17,8,0,288,64,1,0,0,0,289,290,3,45,22,0,290,291,3,21,10,0,291, - 292,3,15,7,0,292,293,3,33,16,0,293,66,1,0,0,0,294,295,3,15,7,0,295, - 296,3,29,14,0,296,297,3,43,21,0,297,298,3,15,7,0,298,68,1,0,0,0, - 299,300,3,9,4,0,300,301,3,35,17,0,301,302,3,35,17,0,302,303,3,29, - 14,0,303,304,3,15,7,0,304,305,3,7,3,0,305,306,3,33,16,0,306,70,1, - 0,0,0,307,308,3,23,11,0,308,309,5,56,0,0,309,72,1,0,0,0,310,311, - 3,23,11,0,311,312,5,49,0,0,312,313,5,54,0,0,313,74,1,0,0,0,314,315, - 3,23,11,0,315,316,5,51,0,0,316,317,5,50,0,0,317,76,1,0,0,0,318,319, - 3,23,11,0,319,320,5,54,0,0,320,321,5,52,0,0,321,78,1,0,0,0,322,323, - 3,17,8,0,323,324,3,37,18,0,324,325,5,51,0,0,325,326,5,50,0,0,326, - 80,1,0,0,0,327,328,3,17,8,0,328,329,3,37,18,0,329,330,5,54,0,0,330, - 331,5,52,0,0,331,82,1,0,0,0,332,333,3,43,21,0,333,334,3,45,22,0, - 334,335,3,41,20,0,335,336,3,23,11,0,336,337,3,33,16,0,337,338,3, - 19,9,0,338,84,1,0,0,0,339,340,3,9,4,0,340,341,3,23,11,0,341,342, - 3,33,16,0,342,343,3,7,3,0,343,344,3,41,20,0,344,345,3,55,27,0,345, - 86,1,0,0,0,346,347,3,45,22,0,347,348,3,23,11,0,348,349,3,31,15,0, - 349,350,3,15,7,0,350,351,3,43,21,0,351,352,3,45,22,0,352,353,3,7, - 3,0,353,354,3,31,15,0,354,355,3,37,18,0,355,88,1,0,0,0,356,357,3, - 45,22,0,357,358,3,23,11,0,358,359,3,31,15,0,359,360,3,15,7,0,360, - 361,3,43,21,0,361,362,3,45,22,0,362,363,3,7,3,0,363,364,3,31,15, - 0,364,365,3,37,18,0,365,366,5,95,0,0,366,367,3,45,22,0,367,368,3, - 57,28,0,368,90,1,0,0,0,369,370,3,13,6,0,370,371,3,7,3,0,371,372, - 3,45,22,0,372,373,3,15,7,0,373,92,1,0,0,0,374,375,3,45,22,0,375, - 376,3,23,11,0,376,377,3,31,15,0,377,378,3,15,7,0,378,94,1,0,0,0, - 379,380,3,23,11,0,380,381,3,33,16,0,381,382,3,45,22,0,382,383,3, - 15,7,0,383,384,3,41,20,0,384,385,3,49,24,0,385,386,3,7,3,0,386,387, - 3,29,14,0,387,388,5,95,0,0,388,389,3,55,27,0,389,390,3,15,7,0,390, - 391,3,7,3,0,391,392,3,41,20,0,392,96,1,0,0,0,393,394,3,23,11,0,394, - 395,3,33,16,0,395,396,3,45,22,0,396,397,3,15,7,0,397,398,3,41,20, - 0,398,399,3,49,24,0,399,400,3,7,3,0,400,401,3,29,14,0,401,402,5, - 95,0,0,402,403,3,13,6,0,403,404,3,7,3,0,404,405,3,55,27,0,405,98, - 1,0,0,0,406,407,3,47,23,0,407,408,3,47,23,0,408,409,3,23,11,0,409, - 410,3,13,6,0,410,100,1,0,0,0,411,412,3,13,6,0,412,413,3,15,7,0,413, - 414,3,11,5,0,414,415,3,23,11,0,415,416,3,31,15,0,416,417,3,7,3,0, - 417,418,3,29,14,0,418,102,1,0,0,0,419,420,3,37,18,0,420,421,3,41, - 20,0,421,422,3,15,7,0,422,423,3,11,5,0,423,424,3,23,11,0,424,425, - 3,43,21,0,425,426,3,23,11,0,426,427,3,35,17,0,427,428,3,33,16,0, - 428,429,5,95,0,0,429,430,3,45,22,0,430,431,3,23,11,0,431,432,3,31, - 15,0,432,433,3,15,7,0,433,434,3,43,21,0,434,435,3,45,22,0,435,436, - 3,7,3,0,436,437,3,31,15,0,437,438,3,37,18,0,438,104,1,0,0,0,439, - 440,3,37,18,0,440,441,3,41,20,0,441,442,3,15,7,0,442,443,3,11,5, - 0,443,444,3,23,11,0,444,445,3,43,21,0,445,446,3,23,11,0,446,447, - 3,35,17,0,447,448,3,33,16,0,448,449,5,95,0,0,449,450,3,45,22,0,450, - 451,3,23,11,0,451,452,3,31,15,0,452,453,3,15,7,0,453,454,3,43,21, - 0,454,455,3,45,22,0,455,456,3,7,3,0,456,457,3,31,15,0,457,458,3, - 37,18,0,458,459,5,95,0,0,459,460,3,45,22,0,460,461,3,57,28,0,461, - 106,1,0,0,0,462,463,3,17,8,0,463,464,3,23,11,0,464,465,3,53,26,0, - 465,466,3,15,7,0,466,467,3,13,6,0,467,468,3,11,5,0,468,469,3,21, - 10,0,469,470,3,7,3,0,470,471,3,41,20,0,471,108,1,0,0,0,472,473,3, - 49,24,0,473,474,3,7,3,0,474,475,3,41,20,0,475,476,3,11,5,0,476,477, - 3,21,10,0,477,478,3,7,3,0,478,479,3,41,20,0,479,110,1,0,0,0,480, - 481,3,17,8,0,481,482,3,23,11,0,482,483,3,53,26,0,483,484,3,15,7, - 0,484,485,3,13,6,0,485,486,3,9,4,0,486,487,3,23,11,0,487,488,3,33, - 16,0,488,489,3,7,3,0,489,490,3,41,20,0,490,491,3,55,27,0,491,112, - 1,0,0,0,492,493,3,43,21,0,493,494,3,45,22,0,494,495,3,41,20,0,495, - 496,3,47,23,0,496,497,3,11,5,0,497,498,3,45,22,0,498,114,1,0,0,0, - 499,500,3,33,16,0,500,501,3,43,21,0,501,502,3,45,22,0,502,503,3, - 41,20,0,503,504,3,47,23,0,504,505,3,11,5,0,505,506,3,45,22,0,506, - 116,1,0,0,0,507,508,3,29,14,0,508,509,3,23,11,0,509,510,3,43,21, - 0,510,511,3,45,22,0,511,118,1,0,0,0,512,513,3,31,15,0,513,514,3, - 7,3,0,514,515,3,37,18,0,515,120,1,0,0,0,516,517,3,7,3,0,517,518, - 3,33,16,0,518,519,3,55,27,0,519,122,1,0,0,0,520,521,3,47,23,0,521, - 522,5,33,0,0,522,124,1,0,0,0,523,524,3,19,9,0,524,525,3,15,7,0,525, - 526,3,35,17,0,526,527,3,31,15,0,527,528,3,15,7,0,528,529,3,45,22, - 0,529,530,3,41,20,0,530,531,3,55,27,0,531,126,1,0,0,0,532,533,3, - 9,4,0,533,534,3,35,17,0,534,535,3,35,17,0,535,536,3,29,14,0,536, - 128,1,0,0,0,537,538,3,43,21,0,538,539,3,45,22,0,539,540,3,41,20, - 0,540,130,1,0,0,0,541,542,3,49,24,0,542,543,3,9,4,0,543,544,3,23, - 11,0,544,545,3,33,16,0,545,132,1,0,0,0,546,547,3,45,22,0,547,548, - 3,43,21,0,548,134,1,0,0,0,549,550,3,45,22,0,550,551,3,43,21,0,551, - 552,3,45,22,0,552,553,3,57,28,0,553,136,1,0,0,0,554,555,3,23,11, - 0,555,556,3,55,27,0,556,557,3,15,7,0,557,558,3,7,3,0,558,559,3,41, - 20,0,559,138,1,0,0,0,560,561,3,23,11,0,561,562,3,13,6,0,562,563, - 3,7,3,0,563,564,3,55,27,0,564,140,1,0,0,0,565,566,3,13,6,0,566,567, - 3,15,7,0,567,568,3,11,5,0,568,142,1,0,0,0,569,570,3,37,18,0,570, - 571,3,45,22,0,571,572,3,43,21,0,572,144,1,0,0,0,573,574,3,37,18, - 0,574,575,3,45,22,0,575,576,3,43,21,0,576,577,3,45,22,0,577,578, - 3,57,28,0,578,146,1,0,0,0,579,580,3,17,8,0,580,581,3,11,5,0,581, - 582,3,21,10,0,582,583,3,7,3,0,583,584,3,41,20,0,584,148,1,0,0,0, - 585,586,3,49,24,0,586,587,3,11,5,0,587,588,3,21,10,0,588,589,3,7, - 3,0,589,590,3,41,20,0,590,150,1,0,0,0,591,592,3,17,8,0,592,593,3, - 9,4,0,593,594,3,23,11,0,594,595,3,33,16,0,595,152,1,0,0,0,596,597, - 5,58,0,0,597,598,5,58,0,0,598,154,1,0,0,0,599,603,7,32,0,0,600,602, - 7,33,0,0,601,600,1,0,0,0,602,605,1,0,0,0,603,601,1,0,0,0,603,604, - 1,0,0,0,604,156,1,0,0,0,605,603,1,0,0,0,606,607,5,60,0,0,607,158, - 1,0,0,0,608,609,5,62,0,0,609,160,1,0,0,0,610,611,5,40,0,0,611,162, - 1,0,0,0,612,613,5,41,0,0,613,164,1,0,0,0,614,615,5,91,0,0,615,166, - 1,0,0,0,616,617,5,93,0,0,617,168,1,0,0,0,618,619,5,44,0,0,619,170, - 1,0,0,0,620,621,5,61,0,0,621,172,1,0,0,0,622,623,5,58,0,0,623,174, - 1,0,0,0,624,625,5,63,0,0,625,176,1,0,0,0,626,627,5,35,0,0,627,178, - 1,0,0,0,628,629,5,46,0,0,629,180,1,0,0,0,9,0,187,199,202,207,218, - 281,284,603,1,0,1,0 + 4, + 0, + 62, + 630, + 6, + -1, + 2, + 0, + 7, + 0, + 2, + 1, + 7, + 1, + 2, + 2, + 7, + 2, + 2, + 3, + 7, + 3, + 2, + 4, + 7, + 4, + 2, + 5, + 7, + 5, + 2, + 6, + 7, + 6, + 2, + 7, + 7, + 7, + 2, + 8, + 7, + 8, + 2, + 9, + 7, + 9, + 2, + 10, + 7, + 10, + 2, + 11, + 7, + 11, + 2, + 12, + 7, + 12, + 2, + 13, + 7, + 13, + 2, + 14, + 7, + 14, + 2, + 15, + 7, + 15, + 2, + 16, + 7, + 16, + 2, + 17, + 7, + 17, + 2, + 18, + 7, + 18, + 2, + 19, + 7, + 19, + 2, + 20, + 7, + 20, + 2, + 21, + 7, + 21, + 2, + 22, + 7, + 22, + 2, + 23, + 7, + 23, + 2, + 24, + 7, + 24, + 2, + 25, + 7, + 25, + 2, + 26, + 7, + 26, + 2, + 27, + 7, + 27, + 2, + 28, + 7, + 28, + 2, + 29, + 7, + 29, + 2, + 30, + 7, + 30, + 2, + 31, + 7, + 31, + 2, + 32, + 7, + 32, + 2, + 33, + 7, + 33, + 2, + 34, + 7, + 34, + 2, + 35, + 7, + 35, + 2, + 36, + 7, + 36, + 2, + 37, + 7, + 37, + 2, + 38, + 7, + 38, + 2, + 39, + 7, + 39, + 2, + 40, + 7, + 40, + 2, + 41, + 7, + 41, + 2, + 42, + 7, + 42, + 2, + 43, + 7, + 43, + 2, + 44, + 7, + 44, + 2, + 45, + 7, + 45, + 2, + 46, + 7, + 46, + 2, + 47, + 7, + 47, + 2, + 48, + 7, + 48, + 2, + 49, + 7, + 49, + 2, + 50, + 7, + 50, + 2, + 51, + 7, + 51, + 2, + 52, + 7, + 52, + 2, + 53, + 7, + 53, + 2, + 54, + 7, + 54, + 2, + 55, + 7, + 55, + 2, + 56, + 7, + 56, + 2, + 57, + 7, + 57, + 2, + 58, + 7, + 58, + 2, + 59, + 7, + 59, + 2, + 60, + 7, + 60, + 2, + 61, + 7, + 61, + 2, + 62, + 7, + 62, + 2, + 63, + 7, + 63, + 2, + 64, + 7, + 64, + 2, + 65, + 7, + 65, + 2, + 66, + 7, + 66, + 2, + 67, + 7, + 67, + 2, + 68, + 7, + 68, + 2, + 69, + 7, + 69, + 2, + 70, + 7, + 70, + 2, + 71, + 7, + 71, + 2, + 72, + 7, + 72, + 2, + 73, + 7, + 73, + 2, + 74, + 7, + 74, + 2, + 75, + 7, + 75, + 2, + 76, + 7, + 76, + 2, + 77, + 7, + 77, + 2, + 78, + 7, + 78, + 2, + 79, + 7, + 79, + 2, + 80, + 7, + 80, + 2, + 81, + 7, + 81, + 2, + 82, + 7, + 82, + 2, + 83, + 7, + 83, + 2, + 84, + 7, + 84, + 2, + 85, + 7, + 85, + 2, + 86, + 7, + 86, + 2, + 87, + 7, + 87, + 2, + 88, + 7, + 88, + 2, + 89, + 7, + 89, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 5, + 0, + 186, + 8, + 0, + 10, + 0, + 12, + 0, + 189, + 9, + 0, + 1, + 0, + 1, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 4, + 1, + 198, + 8, + 1, + 11, + 1, + 12, + 1, + 199, + 1, + 1, + 3, + 1, + 203, + 8, + 1, + 1, + 1, + 5, + 1, + 206, + 8, + 1, + 10, + 1, + 12, + 1, + 209, + 9, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 2, + 4, + 2, + 217, + 8, + 2, + 11, + 2, + 12, + 2, + 218, + 1, + 2, + 1, + 2, + 1, + 3, + 1, + 3, + 1, + 4, + 1, + 4, + 1, + 5, + 1, + 5, + 1, + 6, + 1, + 6, + 1, + 7, + 1, + 7, + 1, + 8, + 1, + 8, + 1, + 9, + 1, + 9, + 1, + 10, + 1, + 10, + 1, + 11, + 1, + 11, + 1, + 12, + 1, + 12, + 1, + 13, + 1, + 13, + 1, + 14, + 1, + 14, + 1, + 15, + 1, + 15, + 1, + 16, + 1, + 16, + 1, + 17, + 1, + 17, + 1, + 18, + 1, + 18, + 1, + 19, + 1, + 19, + 1, + 20, + 1, + 20, + 1, + 21, + 1, + 21, + 1, + 22, + 1, + 22, + 1, + 23, + 1, + 23, + 1, + 24, + 1, + 24, + 1, + 25, + 1, + 25, + 1, + 26, + 1, + 26, + 1, + 27, + 1, + 27, + 1, + 28, + 1, + 28, + 1, + 29, + 1, + 29, + 1, + 30, + 1, + 30, + 1, + 30, + 5, + 30, + 280, + 8, + 30, + 10, + 30, + 12, + 30, + 283, + 9, + 30, + 3, + 30, + 285, + 8, + 30, + 1, + 31, + 1, + 31, + 1, + 31, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 32, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 33, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 34, + 1, + 35, + 1, + 35, + 1, + 35, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 36, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 37, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 38, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 39, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 40, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 41, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 42, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 43, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 44, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 45, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 46, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 47, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 48, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 49, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 50, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 51, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 52, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 53, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 54, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 55, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 56, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 57, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 58, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 59, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 60, + 1, + 61, + 1, + 61, + 1, + 61, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 62, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 63, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 64, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 65, + 1, + 66, + 1, + 66, + 1, + 66, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 67, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 68, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 69, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 70, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 71, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 72, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 73, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 74, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 75, + 1, + 76, + 1, + 76, + 1, + 76, + 1, + 77, + 1, + 77, + 5, + 77, + 602, + 8, + 77, + 10, + 77, + 12, + 77, + 605, + 9, + 77, + 1, + 78, + 1, + 78, + 1, + 79, + 1, + 79, + 1, + 80, + 1, + 80, + 1, + 81, + 1, + 81, + 1, + 82, + 1, + 82, + 1, + 83, + 1, + 83, + 1, + 84, + 1, + 84, + 1, + 85, + 1, + 85, + 1, + 86, + 1, + 86, + 1, + 87, + 1, + 87, + 1, + 88, + 1, + 88, + 1, + 89, + 1, + 89, + 0, + 0, + 90, + 1, + 1, + 3, + 2, + 5, + 3, + 7, + 0, + 9, + 0, + 11, + 0, + 13, + 0, + 15, + 0, + 17, + 0, + 19, + 0, + 21, + 0, + 23, + 0, + 25, + 0, + 27, + 0, + 29, + 0, + 31, + 0, + 33, + 0, + 35, + 0, + 37, + 0, + 39, + 0, + 41, + 0, + 43, + 0, + 45, + 0, + 47, + 0, + 49, + 0, + 51, + 0, + 53, + 0, + 55, + 0, + 57, + 0, + 59, + 0, + 61, + 0, + 63, + 4, + 65, + 5, + 67, + 6, + 69, + 7, + 71, + 8, + 73, + 9, + 75, + 10, + 77, + 11, + 79, + 12, + 81, + 13, + 83, + 14, + 85, + 15, + 87, + 16, + 89, + 17, + 91, + 18, + 93, + 19, + 95, + 20, + 97, + 21, + 99, + 22, + 101, + 23, + 103, + 24, + 105, + 25, + 107, + 26, + 109, + 27, + 111, + 28, + 113, + 29, + 115, + 30, + 117, + 31, + 119, + 32, + 121, + 33, + 123, + 34, + 125, + 35, + 127, + 36, + 129, + 37, + 131, + 38, + 133, + 39, + 135, + 40, + 137, + 41, + 139, + 42, + 141, + 43, + 143, + 44, + 145, + 45, + 147, + 46, + 149, + 47, + 151, + 48, + 153, + 49, + 155, + 50, + 157, + 51, + 159, + 52, + 161, + 53, + 163, + 54, + 165, + 55, + 167, + 56, + 169, + 57, + 171, + 58, + 173, + 59, + 175, + 60, + 177, + 61, + 179, + 62, + 1, + 0, + 34, + 2, + 0, + 10, + 10, + 13, + 13, + 1, + 0, + 42, + 42, + 2, + 0, + 42, + 42, + 47, + 47, + 3, + 0, + 9, + 10, + 13, + 13, + 32, + 32, + 2, + 0, + 65, + 65, + 97, + 97, + 2, + 0, + 66, + 66, + 98, + 98, + 2, + 0, + 67, + 67, + 99, + 99, + 2, + 0, + 68, + 68, + 100, + 100, + 2, + 0, + 69, + 69, + 101, + 101, + 2, + 0, + 70, + 70, + 102, + 102, + 2, + 0, + 71, + 71, + 103, + 103, + 2, + 0, + 72, + 72, + 104, + 104, + 2, + 0, + 73, + 73, + 105, + 105, + 2, + 0, + 74, + 74, + 106, + 106, + 2, + 0, + 75, + 75, + 107, + 107, + 2, + 0, + 76, + 76, + 108, + 108, + 2, + 0, + 77, + 77, + 109, + 109, + 2, + 0, + 78, + 78, + 110, + 110, + 2, + 0, + 79, + 79, + 111, + 111, + 2, + 0, + 80, + 80, + 112, + 112, + 2, + 0, + 81, + 81, + 113, + 113, + 2, + 0, + 82, + 82, + 114, + 114, + 2, + 0, + 83, + 83, + 115, + 115, + 2, + 0, + 84, + 84, + 116, + 116, + 2, + 0, + 85, + 85, + 117, + 117, + 2, + 0, + 86, + 86, + 118, + 118, + 2, + 0, + 87, + 87, + 119, + 119, + 2, + 0, + 88, + 88, + 120, + 120, + 2, + 0, + 89, + 89, + 121, + 121, + 2, + 0, + 90, + 90, + 122, + 122, + 1, + 0, + 48, + 57, + 1, + 0, + 49, + 57, + 3, + 0, + 65, + 90, + 95, + 95, + 97, + 122, + 4, + 0, + 48, + 57, + 65, + 90, + 95, + 95, + 97, + 122, + 609, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 3, + 1, + 0, + 0, + 0, + 0, + 5, + 1, + 0, + 0, + 0, + 0, + 63, + 1, + 0, + 0, + 0, + 0, + 65, + 1, + 0, + 0, + 0, + 0, + 67, + 1, + 0, + 0, + 0, + 0, + 69, + 1, + 0, + 0, + 0, + 0, + 71, + 1, + 0, + 0, + 0, + 0, + 73, + 1, + 0, + 0, + 0, + 0, + 75, + 1, + 0, + 0, + 0, + 0, + 77, + 1, + 0, + 0, + 0, + 0, + 79, + 1, + 0, + 0, + 0, + 0, + 81, + 1, + 0, + 0, + 0, + 0, + 83, + 1, + 0, + 0, + 0, + 0, + 85, + 1, + 0, + 0, + 0, + 0, + 87, + 1, + 0, + 0, + 0, + 0, + 89, + 1, + 0, + 0, + 0, + 0, + 91, + 1, + 0, + 0, + 0, + 0, + 93, + 1, + 0, + 0, + 0, + 0, + 95, + 1, + 0, + 0, + 0, + 0, + 97, + 1, + 0, + 0, + 0, + 0, + 99, + 1, + 0, + 0, + 0, + 0, + 101, + 1, + 0, + 0, + 0, + 0, + 103, + 1, + 0, + 0, + 0, + 0, + 105, + 1, + 0, + 0, + 0, + 0, + 107, + 1, + 0, + 0, + 0, + 0, + 109, + 1, + 0, + 0, + 0, + 0, + 111, + 1, + 0, + 0, + 0, + 0, + 113, + 1, + 0, + 0, + 0, + 0, + 115, + 1, + 0, + 0, + 0, + 0, + 117, + 1, + 0, + 0, + 0, + 0, + 119, + 1, + 0, + 0, + 0, + 0, + 121, + 1, + 0, + 0, + 0, + 0, + 123, + 1, + 0, + 0, + 0, + 0, + 125, + 1, + 0, + 0, + 0, + 0, + 127, + 1, + 0, + 0, + 0, + 0, + 129, + 1, + 0, + 0, + 0, + 0, + 131, + 1, + 0, + 0, + 0, + 0, + 133, + 1, + 0, + 0, + 0, + 0, + 135, + 1, + 0, + 0, + 0, + 0, + 137, + 1, + 0, + 0, + 0, + 0, + 139, + 1, + 0, + 0, + 0, + 0, + 141, + 1, + 0, + 0, + 0, + 0, + 143, + 1, + 0, + 0, + 0, + 0, + 145, + 1, + 0, + 0, + 0, + 0, + 147, + 1, + 0, + 0, + 0, + 0, + 149, + 1, + 0, + 0, + 0, + 0, + 151, + 1, + 0, + 0, + 0, + 0, + 153, + 1, + 0, + 0, + 0, + 0, + 155, + 1, + 0, + 0, + 0, + 0, + 157, + 1, + 0, + 0, + 0, + 0, + 159, + 1, + 0, + 0, + 0, + 0, + 161, + 1, + 0, + 0, + 0, + 0, + 163, + 1, + 0, + 0, + 0, + 0, + 165, + 1, + 0, + 0, + 0, + 0, + 167, + 1, + 0, + 0, + 0, + 0, + 169, + 1, + 0, + 0, + 0, + 0, + 171, + 1, + 0, + 0, + 0, + 0, + 173, + 1, + 0, + 0, + 0, + 0, + 175, + 1, + 0, + 0, + 0, + 0, + 177, + 1, + 0, + 0, + 0, + 0, + 179, + 1, + 0, + 0, + 0, + 1, + 181, + 1, + 0, + 0, + 0, + 3, + 192, + 1, + 0, + 0, + 0, + 5, + 216, + 1, + 0, + 0, + 0, + 7, + 222, + 1, + 0, + 0, + 0, + 9, + 224, + 1, + 0, + 0, + 0, + 11, + 226, + 1, + 0, + 0, + 0, + 13, + 228, + 1, + 0, + 0, + 0, + 15, + 230, + 1, + 0, + 0, + 0, + 17, + 232, + 1, + 0, + 0, + 0, + 19, + 234, + 1, + 0, + 0, + 0, + 21, + 236, + 1, + 0, + 0, + 0, + 23, + 238, + 1, + 0, + 0, + 0, + 25, + 240, + 1, + 0, + 0, + 0, + 27, + 242, + 1, + 0, + 0, + 0, + 29, + 244, + 1, + 0, + 0, + 0, + 31, + 246, + 1, + 0, + 0, + 0, + 33, + 248, + 1, + 0, + 0, + 0, + 35, + 250, + 1, + 0, + 0, + 0, + 37, + 252, + 1, + 0, + 0, + 0, + 39, + 254, + 1, + 0, + 0, + 0, + 41, + 256, + 1, + 0, + 0, + 0, + 43, + 258, + 1, + 0, + 0, + 0, + 45, + 260, + 1, + 0, + 0, + 0, + 47, + 262, + 1, + 0, + 0, + 0, + 49, + 264, + 1, + 0, + 0, + 0, + 51, + 266, + 1, + 0, + 0, + 0, + 53, + 268, + 1, + 0, + 0, + 0, + 55, + 270, + 1, + 0, + 0, + 0, + 57, + 272, + 1, + 0, + 0, + 0, + 59, + 274, + 1, + 0, + 0, + 0, + 61, + 284, + 1, + 0, + 0, + 0, + 63, + 286, + 1, + 0, + 0, + 0, + 65, + 289, + 1, + 0, + 0, + 0, + 67, + 294, + 1, + 0, + 0, + 0, + 69, + 299, + 1, + 0, + 0, + 0, + 71, + 307, + 1, + 0, + 0, + 0, + 73, + 310, + 1, + 0, + 0, + 0, + 75, + 314, + 1, + 0, + 0, + 0, + 77, + 318, + 1, + 0, + 0, + 0, + 79, + 322, + 1, + 0, + 0, + 0, + 81, + 327, + 1, + 0, + 0, + 0, + 83, + 332, + 1, + 0, + 0, + 0, + 85, + 339, + 1, + 0, + 0, + 0, + 87, + 346, + 1, + 0, + 0, + 0, + 89, + 356, + 1, + 0, + 0, + 0, + 91, + 369, + 1, + 0, + 0, + 0, + 93, + 374, + 1, + 0, + 0, + 0, + 95, + 379, + 1, + 0, + 0, + 0, + 97, + 393, + 1, + 0, + 0, + 0, + 99, + 406, + 1, + 0, + 0, + 0, + 101, + 411, + 1, + 0, + 0, + 0, + 103, + 419, + 1, + 0, + 0, + 0, + 105, + 439, + 1, + 0, + 0, + 0, + 107, + 462, + 1, + 0, + 0, + 0, + 109, + 472, + 1, + 0, + 0, + 0, + 111, + 480, + 1, + 0, + 0, + 0, + 113, + 492, + 1, + 0, + 0, + 0, + 115, + 499, + 1, + 0, + 0, + 0, + 117, + 507, + 1, + 0, + 0, + 0, + 119, + 512, + 1, + 0, + 0, + 0, + 121, + 516, + 1, + 0, + 0, + 0, + 123, + 520, + 1, + 0, + 0, + 0, + 125, + 523, + 1, + 0, + 0, + 0, + 127, + 532, + 1, + 0, + 0, + 0, + 129, + 537, + 1, + 0, + 0, + 0, + 131, + 541, + 1, + 0, + 0, + 0, + 133, + 546, + 1, + 0, + 0, + 0, + 135, + 549, + 1, + 0, + 0, + 0, + 137, + 554, + 1, + 0, + 0, + 0, + 139, + 560, + 1, + 0, + 0, + 0, + 141, + 565, + 1, + 0, + 0, + 0, + 143, + 569, + 1, + 0, + 0, + 0, + 145, + 573, + 1, + 0, + 0, + 0, + 147, + 579, + 1, + 0, + 0, + 0, + 149, + 585, + 1, + 0, + 0, + 0, + 151, + 591, + 1, + 0, + 0, + 0, + 153, + 596, + 1, + 0, + 0, + 0, + 155, + 599, + 1, + 0, + 0, + 0, + 157, + 606, + 1, + 0, + 0, + 0, + 159, + 608, + 1, + 0, + 0, + 0, + 161, + 610, + 1, + 0, + 0, + 0, + 163, + 612, + 1, + 0, + 0, + 0, + 165, + 614, + 1, + 0, + 0, + 0, + 167, + 616, + 1, + 0, + 0, + 0, + 169, + 618, + 1, + 0, + 0, + 0, + 171, + 620, + 1, + 0, + 0, + 0, + 173, + 622, + 1, + 0, + 0, + 0, + 175, + 624, + 1, + 0, + 0, + 0, + 177, + 626, + 1, + 0, + 0, + 0, + 179, + 628, + 1, + 0, + 0, + 0, + 181, + 182, + 5, + 47, + 0, + 0, + 182, + 183, + 5, + 47, + 0, + 0, + 183, + 187, + 1, + 0, + 0, + 0, + 184, + 186, + 8, + 0, + 0, + 0, + 185, + 184, + 1, + 0, + 0, + 0, + 186, + 189, + 1, + 0, + 0, + 0, + 187, + 185, + 1, + 0, + 0, + 0, + 187, + 188, + 1, + 0, + 0, + 0, + 188, + 190, + 1, + 0, + 0, + 0, + 189, + 187, + 1, + 0, + 0, + 0, + 190, + 191, + 6, + 0, + 0, + 0, + 191, + 2, + 1, + 0, + 0, + 0, + 192, + 193, + 5, + 47, + 0, + 0, + 193, + 194, + 5, + 42, + 0, + 0, + 194, + 202, + 1, + 0, + 0, + 0, + 195, + 203, + 8, + 1, + 0, + 0, + 196, + 198, + 5, + 42, + 0, + 0, + 197, + 196, + 1, + 0, + 0, + 0, + 198, + 199, + 1, + 0, + 0, + 0, + 199, + 197, + 1, + 0, + 0, + 0, + 199, + 200, + 1, + 0, + 0, + 0, + 200, + 201, + 1, + 0, + 0, + 0, + 201, + 203, + 8, + 2, + 0, + 0, + 202, + 195, + 1, + 0, + 0, + 0, + 202, + 197, + 1, + 0, + 0, + 0, + 203, + 207, + 1, + 0, + 0, + 0, + 204, + 206, + 5, + 42, + 0, + 0, + 205, + 204, + 1, + 0, + 0, + 0, + 206, + 209, + 1, + 0, + 0, + 0, + 207, + 205, + 1, + 0, + 0, + 0, + 207, + 208, + 1, + 0, + 0, + 0, + 208, + 210, + 1, + 0, + 0, + 0, + 209, + 207, + 1, + 0, + 0, + 0, + 210, + 211, + 5, + 42, + 0, + 0, + 211, + 212, + 5, + 47, + 0, + 0, + 212, + 213, + 1, + 0, + 0, + 0, + 213, + 214, + 6, + 1, + 0, + 0, + 214, + 4, + 1, + 0, + 0, + 0, + 215, + 217, + 7, + 3, + 0, + 0, + 216, + 215, + 1, + 0, + 0, + 0, + 217, + 218, + 1, + 0, + 0, + 0, + 218, + 216, + 1, + 0, + 0, + 0, + 218, + 219, + 1, + 0, + 0, + 0, + 219, + 220, + 1, + 0, + 0, + 0, + 220, + 221, + 6, + 2, + 0, + 0, + 221, + 6, + 1, + 0, + 0, + 0, + 222, + 223, + 7, + 4, + 0, + 0, + 223, + 8, + 1, + 0, + 0, + 0, + 224, + 225, + 7, + 5, + 0, + 0, + 225, + 10, + 1, + 0, + 0, + 0, + 226, + 227, + 7, + 6, + 0, + 0, + 227, + 12, + 1, + 0, + 0, + 0, + 228, + 229, + 7, + 7, + 0, + 0, + 229, + 14, + 1, + 0, + 0, + 0, + 230, + 231, + 7, + 8, + 0, + 0, + 231, + 16, + 1, + 0, + 0, + 0, + 232, + 233, + 7, + 9, + 0, + 0, + 233, + 18, + 1, + 0, + 0, + 0, + 234, + 235, + 7, + 10, + 0, + 0, + 235, + 20, + 1, + 0, + 0, + 0, + 236, + 237, + 7, + 11, + 0, + 0, + 237, + 22, + 1, + 0, + 0, + 0, + 238, + 239, + 7, + 12, + 0, + 0, + 239, + 24, + 1, + 0, + 0, + 0, + 240, + 241, + 7, + 13, + 0, + 0, + 241, + 26, + 1, + 0, + 0, + 0, + 242, + 243, + 7, + 14, + 0, + 0, + 243, + 28, + 1, + 0, + 0, + 0, + 244, + 245, + 7, + 15, + 0, + 0, + 245, + 30, + 1, + 0, + 0, + 0, + 246, + 247, + 7, + 16, + 0, + 0, + 247, + 32, + 1, + 0, + 0, + 0, + 248, + 249, + 7, + 17, + 0, + 0, + 249, + 34, + 1, + 0, + 0, + 0, + 250, + 251, + 7, + 18, + 0, + 0, + 251, + 36, + 1, + 0, + 0, + 0, + 252, + 253, + 7, + 19, + 0, + 0, + 253, + 38, + 1, + 0, + 0, + 0, + 254, + 255, + 7, + 20, + 0, + 0, + 255, + 40, + 1, + 0, + 0, + 0, + 256, + 257, + 7, + 21, + 0, + 0, + 257, + 42, + 1, + 0, + 0, + 0, + 258, + 259, + 7, + 22, + 0, + 0, + 259, + 44, + 1, + 0, + 0, + 0, + 260, + 261, + 7, + 23, + 0, + 0, + 261, + 46, + 1, + 0, + 0, + 0, + 262, + 263, + 7, + 24, + 0, + 0, + 263, + 48, + 1, + 0, + 0, + 0, + 264, + 265, + 7, + 25, + 0, + 0, + 265, + 50, + 1, + 0, + 0, + 0, + 266, + 267, + 7, + 26, + 0, + 0, + 267, + 52, + 1, + 0, + 0, + 0, + 268, + 269, + 7, + 27, + 0, + 0, + 269, + 54, + 1, + 0, + 0, + 0, + 270, + 271, + 7, + 28, + 0, + 0, + 271, + 56, + 1, + 0, + 0, + 0, + 272, + 273, + 7, + 29, + 0, + 0, + 273, + 58, + 1, + 0, + 0, + 0, + 274, + 275, + 7, + 30, + 0, + 0, + 275, + 60, + 1, + 0, + 0, + 0, + 276, + 285, + 5, + 48, + 0, + 0, + 277, + 281, + 7, + 31, + 0, + 0, + 278, + 280, + 7, + 30, + 0, + 0, + 279, + 278, + 1, + 0, + 0, + 0, + 280, + 283, + 1, + 0, + 0, + 0, + 281, + 279, + 1, + 0, + 0, + 0, + 281, + 282, + 1, + 0, + 0, + 0, + 282, + 285, + 1, + 0, + 0, + 0, + 283, + 281, + 1, + 0, + 0, + 0, + 284, + 276, + 1, + 0, + 0, + 0, + 284, + 277, + 1, + 0, + 0, + 0, + 285, + 62, + 1, + 0, + 0, + 0, + 286, + 287, + 3, + 23, + 11, + 0, + 287, + 288, + 3, + 17, + 8, + 0, + 288, + 64, + 1, + 0, + 0, + 0, + 289, + 290, + 3, + 45, + 22, + 0, + 290, + 291, + 3, + 21, + 10, + 0, + 291, + 292, + 3, + 15, + 7, + 0, + 292, + 293, + 3, + 33, + 16, + 0, + 293, + 66, + 1, + 0, + 0, + 0, + 294, + 295, + 3, + 15, + 7, + 0, + 295, + 296, + 3, + 29, + 14, + 0, + 296, + 297, + 3, + 43, + 21, + 0, + 297, + 298, + 3, + 15, + 7, + 0, + 298, + 68, + 1, + 0, + 0, + 0, + 299, + 300, + 3, + 9, + 4, + 0, + 300, + 301, + 3, + 35, + 17, + 0, + 301, + 302, + 3, + 35, + 17, + 0, + 302, + 303, + 3, + 29, + 14, + 0, + 303, + 304, + 3, + 15, + 7, + 0, + 304, + 305, + 3, + 7, + 3, + 0, + 305, + 306, + 3, + 33, + 16, + 0, + 306, + 70, + 1, + 0, + 0, + 0, + 307, + 308, + 3, + 23, + 11, + 0, + 308, + 309, + 5, + 56, + 0, + 0, + 309, + 72, + 1, + 0, + 0, + 0, + 310, + 311, + 3, + 23, + 11, + 0, + 311, + 312, + 5, + 49, + 0, + 0, + 312, + 313, + 5, + 54, + 0, + 0, + 313, + 74, + 1, + 0, + 0, + 0, + 314, + 315, + 3, + 23, + 11, + 0, + 315, + 316, + 5, + 51, + 0, + 0, + 316, + 317, + 5, + 50, + 0, + 0, + 317, + 76, + 1, + 0, + 0, + 0, + 318, + 319, + 3, + 23, + 11, + 0, + 319, + 320, + 5, + 54, + 0, + 0, + 320, + 321, + 5, + 52, + 0, + 0, + 321, + 78, + 1, + 0, + 0, + 0, + 322, + 323, + 3, + 17, + 8, + 0, + 323, + 324, + 3, + 37, + 18, + 0, + 324, + 325, + 5, + 51, + 0, + 0, + 325, + 326, + 5, + 50, + 0, + 0, + 326, + 80, + 1, + 0, + 0, + 0, + 327, + 328, + 3, + 17, + 8, + 0, + 328, + 329, + 3, + 37, + 18, + 0, + 329, + 330, + 5, + 54, + 0, + 0, + 330, + 331, + 5, + 52, + 0, + 0, + 331, + 82, + 1, + 0, + 0, + 0, + 332, + 333, + 3, + 43, + 21, + 0, + 333, + 334, + 3, + 45, + 22, + 0, + 334, + 335, + 3, + 41, + 20, + 0, + 335, + 336, + 3, + 23, + 11, + 0, + 336, + 337, + 3, + 33, + 16, + 0, + 337, + 338, + 3, + 19, + 9, + 0, + 338, + 84, + 1, + 0, + 0, + 0, + 339, + 340, + 3, + 9, + 4, + 0, + 340, + 341, + 3, + 23, + 11, + 0, + 341, + 342, + 3, + 33, + 16, + 0, + 342, + 343, + 3, + 7, + 3, + 0, + 343, + 344, + 3, + 41, + 20, + 0, + 344, + 345, + 3, + 55, + 27, + 0, + 345, + 86, + 1, + 0, + 0, + 0, + 346, + 347, + 3, + 45, + 22, + 0, + 347, + 348, + 3, + 23, + 11, + 0, + 348, + 349, + 3, + 31, + 15, + 0, + 349, + 350, + 3, + 15, + 7, + 0, + 350, + 351, + 3, + 43, + 21, + 0, + 351, + 352, + 3, + 45, + 22, + 0, + 352, + 353, + 3, + 7, + 3, + 0, + 353, + 354, + 3, + 31, + 15, + 0, + 354, + 355, + 3, + 37, + 18, + 0, + 355, + 88, + 1, + 0, + 0, + 0, + 356, + 357, + 3, + 45, + 22, + 0, + 357, + 358, + 3, + 23, + 11, + 0, + 358, + 359, + 3, + 31, + 15, + 0, + 359, + 360, + 3, + 15, + 7, + 0, + 360, + 361, + 3, + 43, + 21, + 0, + 361, + 362, + 3, + 45, + 22, + 0, + 362, + 363, + 3, + 7, + 3, + 0, + 363, + 364, + 3, + 31, + 15, + 0, + 364, + 365, + 3, + 37, + 18, + 0, + 365, + 366, + 5, + 95, + 0, + 0, + 366, + 367, + 3, + 45, + 22, + 0, + 367, + 368, + 3, + 57, + 28, + 0, + 368, + 90, + 1, + 0, + 0, + 0, + 369, + 370, + 3, + 13, + 6, + 0, + 370, + 371, + 3, + 7, + 3, + 0, + 371, + 372, + 3, + 45, + 22, + 0, + 372, + 373, + 3, + 15, + 7, + 0, + 373, + 92, + 1, + 0, + 0, + 0, + 374, + 375, + 3, + 45, + 22, + 0, + 375, + 376, + 3, + 23, + 11, + 0, + 376, + 377, + 3, + 31, + 15, + 0, + 377, + 378, + 3, + 15, + 7, + 0, + 378, + 94, + 1, + 0, + 0, + 0, + 379, + 380, + 3, + 23, + 11, + 0, + 380, + 381, + 3, + 33, + 16, + 0, + 381, + 382, + 3, + 45, + 22, + 0, + 382, + 383, + 3, + 15, + 7, + 0, + 383, + 384, + 3, + 41, + 20, + 0, + 384, + 385, + 3, + 49, + 24, + 0, + 385, + 386, + 3, + 7, + 3, + 0, + 386, + 387, + 3, + 29, + 14, + 0, + 387, + 388, + 5, + 95, + 0, + 0, + 388, + 389, + 3, + 55, + 27, + 0, + 389, + 390, + 3, + 15, + 7, + 0, + 390, + 391, + 3, + 7, + 3, + 0, + 391, + 392, + 3, + 41, + 20, + 0, + 392, + 96, + 1, + 0, + 0, + 0, + 393, + 394, + 3, + 23, + 11, + 0, + 394, + 395, + 3, + 33, + 16, + 0, + 395, + 396, + 3, + 45, + 22, + 0, + 396, + 397, + 3, + 15, + 7, + 0, + 397, + 398, + 3, + 41, + 20, + 0, + 398, + 399, + 3, + 49, + 24, + 0, + 399, + 400, + 3, + 7, + 3, + 0, + 400, + 401, + 3, + 29, + 14, + 0, + 401, + 402, + 5, + 95, + 0, + 0, + 402, + 403, + 3, + 13, + 6, + 0, + 403, + 404, + 3, + 7, + 3, + 0, + 404, + 405, + 3, + 55, + 27, + 0, + 405, + 98, + 1, + 0, + 0, + 0, + 406, + 407, + 3, + 47, + 23, + 0, + 407, + 408, + 3, + 47, + 23, + 0, + 408, + 409, + 3, + 23, + 11, + 0, + 409, + 410, + 3, + 13, + 6, + 0, + 410, + 100, + 1, + 0, + 0, + 0, + 411, + 412, + 3, + 13, + 6, + 0, + 412, + 413, + 3, + 15, + 7, + 0, + 413, + 414, + 3, + 11, + 5, + 0, + 414, + 415, + 3, + 23, + 11, + 0, + 415, + 416, + 3, + 31, + 15, + 0, + 416, + 417, + 3, + 7, + 3, + 0, + 417, + 418, + 3, + 29, + 14, + 0, + 418, + 102, + 1, + 0, + 0, + 0, + 419, + 420, + 3, + 37, + 18, + 0, + 420, + 421, + 3, + 41, + 20, + 0, + 421, + 422, + 3, + 15, + 7, + 0, + 422, + 423, + 3, + 11, + 5, + 0, + 423, + 424, + 3, + 23, + 11, + 0, + 424, + 425, + 3, + 43, + 21, + 0, + 425, + 426, + 3, + 23, + 11, + 0, + 426, + 427, + 3, + 35, + 17, + 0, + 427, + 428, + 3, + 33, + 16, + 0, + 428, + 429, + 5, + 95, + 0, + 0, + 429, + 430, + 3, + 45, + 22, + 0, + 430, + 431, + 3, + 23, + 11, + 0, + 431, + 432, + 3, + 31, + 15, + 0, + 432, + 433, + 3, + 15, + 7, + 0, + 433, + 434, + 3, + 43, + 21, + 0, + 434, + 435, + 3, + 45, + 22, + 0, + 435, + 436, + 3, + 7, + 3, + 0, + 436, + 437, + 3, + 31, + 15, + 0, + 437, + 438, + 3, + 37, + 18, + 0, + 438, + 104, + 1, + 0, + 0, + 0, + 439, + 440, + 3, + 37, + 18, + 0, + 440, + 441, + 3, + 41, + 20, + 0, + 441, + 442, + 3, + 15, + 7, + 0, + 442, + 443, + 3, + 11, + 5, + 0, + 443, + 444, + 3, + 23, + 11, + 0, + 444, + 445, + 3, + 43, + 21, + 0, + 445, + 446, + 3, + 23, + 11, + 0, + 446, + 447, + 3, + 35, + 17, + 0, + 447, + 448, + 3, + 33, + 16, + 0, + 448, + 449, + 5, + 95, + 0, + 0, + 449, + 450, + 3, + 45, + 22, + 0, + 450, + 451, + 3, + 23, + 11, + 0, + 451, + 452, + 3, + 31, + 15, + 0, + 452, + 453, + 3, + 15, + 7, + 0, + 453, + 454, + 3, + 43, + 21, + 0, + 454, + 455, + 3, + 45, + 22, + 0, + 455, + 456, + 3, + 7, + 3, + 0, + 456, + 457, + 3, + 31, + 15, + 0, + 457, + 458, + 3, + 37, + 18, + 0, + 458, + 459, + 5, + 95, + 0, + 0, + 459, + 460, + 3, + 45, + 22, + 0, + 460, + 461, + 3, + 57, + 28, + 0, + 461, + 106, + 1, + 0, + 0, + 0, + 462, + 463, + 3, + 17, + 8, + 0, + 463, + 464, + 3, + 23, + 11, + 0, + 464, + 465, + 3, + 53, + 26, + 0, + 465, + 466, + 3, + 15, + 7, + 0, + 466, + 467, + 3, + 13, + 6, + 0, + 467, + 468, + 3, + 11, + 5, + 0, + 468, + 469, + 3, + 21, + 10, + 0, + 469, + 470, + 3, + 7, + 3, + 0, + 470, + 471, + 3, + 41, + 20, + 0, + 471, + 108, + 1, + 0, + 0, + 0, + 472, + 473, + 3, + 49, + 24, + 0, + 473, + 474, + 3, + 7, + 3, + 0, + 474, + 475, + 3, + 41, + 20, + 0, + 475, + 476, + 3, + 11, + 5, + 0, + 476, + 477, + 3, + 21, + 10, + 0, + 477, + 478, + 3, + 7, + 3, + 0, + 478, + 479, + 3, + 41, + 20, + 0, + 479, + 110, + 1, + 0, + 0, + 0, + 480, + 481, + 3, + 17, + 8, + 0, + 481, + 482, + 3, + 23, + 11, + 0, + 482, + 483, + 3, + 53, + 26, + 0, + 483, + 484, + 3, + 15, + 7, + 0, + 484, + 485, + 3, + 13, + 6, + 0, + 485, + 486, + 3, + 9, + 4, + 0, + 486, + 487, + 3, + 23, + 11, + 0, + 487, + 488, + 3, + 33, + 16, + 0, + 488, + 489, + 3, + 7, + 3, + 0, + 489, + 490, + 3, + 41, + 20, + 0, + 490, + 491, + 3, + 55, + 27, + 0, + 491, + 112, + 1, + 0, + 0, + 0, + 492, + 493, + 3, + 43, + 21, + 0, + 493, + 494, + 3, + 45, + 22, + 0, + 494, + 495, + 3, + 41, + 20, + 0, + 495, + 496, + 3, + 47, + 23, + 0, + 496, + 497, + 3, + 11, + 5, + 0, + 497, + 498, + 3, + 45, + 22, + 0, + 498, + 114, + 1, + 0, + 0, + 0, + 499, + 500, + 3, + 33, + 16, + 0, + 500, + 501, + 3, + 43, + 21, + 0, + 501, + 502, + 3, + 45, + 22, + 0, + 502, + 503, + 3, + 41, + 20, + 0, + 503, + 504, + 3, + 47, + 23, + 0, + 504, + 505, + 3, + 11, + 5, + 0, + 505, + 506, + 3, + 45, + 22, + 0, + 506, + 116, + 1, + 0, + 0, + 0, + 507, + 508, + 3, + 29, + 14, + 0, + 508, + 509, + 3, + 23, + 11, + 0, + 509, + 510, + 3, + 43, + 21, + 0, + 510, + 511, + 3, + 45, + 22, + 0, + 511, + 118, + 1, + 0, + 0, + 0, + 512, + 513, + 3, + 31, + 15, + 0, + 513, + 514, + 3, + 7, + 3, + 0, + 514, + 515, + 3, + 37, + 18, + 0, + 515, + 120, + 1, + 0, + 0, + 0, + 516, + 517, + 3, + 7, + 3, + 0, + 517, + 518, + 3, + 33, + 16, + 0, + 518, + 519, + 3, + 55, + 27, + 0, + 519, + 122, + 1, + 0, + 0, + 0, + 520, + 521, + 3, + 47, + 23, + 0, + 521, + 522, + 5, + 33, + 0, + 0, + 522, + 124, + 1, + 0, + 0, + 0, + 523, + 524, + 3, + 19, + 9, + 0, + 524, + 525, + 3, + 15, + 7, + 0, + 525, + 526, + 3, + 35, + 17, + 0, + 526, + 527, + 3, + 31, + 15, + 0, + 527, + 528, + 3, + 15, + 7, + 0, + 528, + 529, + 3, + 45, + 22, + 0, + 529, + 530, + 3, + 41, + 20, + 0, + 530, + 531, + 3, + 55, + 27, + 0, + 531, + 126, + 1, + 0, + 0, + 0, + 532, + 533, + 3, + 9, + 4, + 0, + 533, + 534, + 3, + 35, + 17, + 0, + 534, + 535, + 3, + 35, + 17, + 0, + 535, + 536, + 3, + 29, + 14, + 0, + 536, + 128, + 1, + 0, + 0, + 0, + 537, + 538, + 3, + 43, + 21, + 0, + 538, + 539, + 3, + 45, + 22, + 0, + 539, + 540, + 3, + 41, + 20, + 0, + 540, + 130, + 1, + 0, + 0, + 0, + 541, + 542, + 3, + 49, + 24, + 0, + 542, + 543, + 3, + 9, + 4, + 0, + 543, + 544, + 3, + 23, + 11, + 0, + 544, + 545, + 3, + 33, + 16, + 0, + 545, + 132, + 1, + 0, + 0, + 0, + 546, + 547, + 3, + 45, + 22, + 0, + 547, + 548, + 3, + 43, + 21, + 0, + 548, + 134, + 1, + 0, + 0, + 0, + 549, + 550, + 3, + 45, + 22, + 0, + 550, + 551, + 3, + 43, + 21, + 0, + 551, + 552, + 3, + 45, + 22, + 0, + 552, + 553, + 3, + 57, + 28, + 0, + 553, + 136, + 1, + 0, + 0, + 0, + 554, + 555, + 3, + 23, + 11, + 0, + 555, + 556, + 3, + 55, + 27, + 0, + 556, + 557, + 3, + 15, + 7, + 0, + 557, + 558, + 3, + 7, + 3, + 0, + 558, + 559, + 3, + 41, + 20, + 0, + 559, + 138, + 1, + 0, + 0, + 0, + 560, + 561, + 3, + 23, + 11, + 0, + 561, + 562, + 3, + 13, + 6, + 0, + 562, + 563, + 3, + 7, + 3, + 0, + 563, + 564, + 3, + 55, + 27, + 0, + 564, + 140, + 1, + 0, + 0, + 0, + 565, + 566, + 3, + 13, + 6, + 0, + 566, + 567, + 3, + 15, + 7, + 0, + 567, + 568, + 3, + 11, + 5, + 0, + 568, + 142, + 1, + 0, + 0, + 0, + 569, + 570, + 3, + 37, + 18, + 0, + 570, + 571, + 3, + 45, + 22, + 0, + 571, + 572, + 3, + 43, + 21, + 0, + 572, + 144, + 1, + 0, + 0, + 0, + 573, + 574, + 3, + 37, + 18, + 0, + 574, + 575, + 3, + 45, + 22, + 0, + 575, + 576, + 3, + 43, + 21, + 0, + 576, + 577, + 3, + 45, + 22, + 0, + 577, + 578, + 3, + 57, + 28, + 0, + 578, + 146, + 1, + 0, + 0, + 0, + 579, + 580, + 3, + 17, + 8, + 0, + 580, + 581, + 3, + 11, + 5, + 0, + 581, + 582, + 3, + 21, + 10, + 0, + 582, + 583, + 3, + 7, + 3, + 0, + 583, + 584, + 3, + 41, + 20, + 0, + 584, + 148, + 1, + 0, + 0, + 0, + 585, + 586, + 3, + 49, + 24, + 0, + 586, + 587, + 3, + 11, + 5, + 0, + 587, + 588, + 3, + 21, + 10, + 0, + 588, + 589, + 3, + 7, + 3, + 0, + 589, + 590, + 3, + 41, + 20, + 0, + 590, + 150, + 1, + 0, + 0, + 0, + 591, + 592, + 3, + 17, + 8, + 0, + 592, + 593, + 3, + 9, + 4, + 0, + 593, + 594, + 3, + 23, + 11, + 0, + 594, + 595, + 3, + 33, + 16, + 0, + 595, + 152, + 1, + 0, + 0, + 0, + 596, + 597, + 5, + 58, + 0, + 0, + 597, + 598, + 5, + 58, + 0, + 0, + 598, + 154, + 1, + 0, + 0, + 0, + 599, + 603, + 7, + 32, + 0, + 0, + 600, + 602, + 7, + 33, + 0, + 0, + 601, + 600, + 1, + 0, + 0, + 0, + 602, + 605, + 1, + 0, + 0, + 0, + 603, + 601, + 1, + 0, + 0, + 0, + 603, + 604, + 1, + 0, + 0, + 0, + 604, + 156, + 1, + 0, + 0, + 0, + 605, + 603, + 1, + 0, + 0, + 0, + 606, + 607, + 5, + 60, + 0, + 0, + 607, + 158, + 1, + 0, + 0, + 0, + 608, + 609, + 5, + 62, + 0, + 0, + 609, + 160, + 1, + 0, + 0, + 0, + 610, + 611, + 5, + 40, + 0, + 0, + 611, + 162, + 1, + 0, + 0, + 0, + 612, + 613, + 5, + 41, + 0, + 0, + 613, + 164, + 1, + 0, + 0, + 0, + 614, + 615, + 5, + 91, + 0, + 0, + 615, + 166, + 1, + 0, + 0, + 0, + 616, + 617, + 5, + 93, + 0, + 0, + 617, + 168, + 1, + 0, + 0, + 0, + 618, + 619, + 5, + 44, + 0, + 0, + 619, + 170, + 1, + 0, + 0, + 0, + 620, + 621, + 5, + 61, + 0, + 0, + 621, + 172, + 1, + 0, + 0, + 0, + 622, + 623, + 5, + 58, + 0, + 0, + 623, + 174, + 1, + 0, + 0, + 0, + 624, + 625, + 5, + 63, + 0, + 0, + 625, + 176, + 1, + 0, + 0, + 0, + 626, + 627, + 5, + 35, + 0, + 0, + 627, + 178, + 1, + 0, + 0, + 0, + 628, + 629, + 5, + 46, + 0, + 0, + 629, + 180, + 1, + 0, + 0, + 0, + 9, + 0, + 187, + 199, + 202, + 207, + 218, + 281, + 284, + 603, + 1, + 0, + 1, + 0, ] + class SubstraitLexer(Lexer): atn = ATNDeserializer().deserialize(serializedATN()) - decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)] LineComment = 1 BlockComment = 2 @@ -302,48 +5422,193 @@ class SubstraitLexer(Lexer): HASH = 61 DOT = 62 - channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + channelNames = ["DEFAULT_TOKEN_CHANNEL", "HIDDEN"] - modeNames = [ "DEFAULT_MODE" ] + modeNames = ["DEFAULT_MODE"] - literalNames = [ "", - "'::'", "'<'", "'>'", "'('", "')'", "'['", "']'", "','", "'='", - "':'", "'?'", "'#'", "'.'" ] + literalNames = [ + "", + "'::'", + "'<'", + "'>'", + "'('", + "')'", + "'['", + "']'", + "','", + "'='", + "':'", + "'?'", + "'#'", + "'.'", + ] - symbolicNames = [ "", - "LineComment", "BlockComment", "Whitespace", "If", "Then", "Else", - "Boolean", "I8", "I16", "I32", "I64", "FP32", "FP64", "String", - "Binary", "Timestamp", "Timestamp_TZ", "Date", "Time", "Interval_Year", - "Interval_Day", "UUID", "Decimal", "Precision_Timestamp", "Precision_Timestamp_TZ", - "FixedChar", "VarChar", "FixedBinary", "Struct", "NStruct", - "List", "Map", "ANY", "UserDefined", "Geometry", "Bool", "Str", - "VBin", "Ts", "TsTZ", "IYear", "IDay", "Dec", "PTs", "PTsTZ", - "FChar", "VChar", "FBin", "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", - "C_ANGLE_BRACKET", "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", - "COMMA", "EQ", "COLON", "QMARK", "HASH", "DOT" ] + symbolicNames = [ + "", + "LineComment", + "BlockComment", + "Whitespace", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "Timestamp_TZ", + "Date", + "Time", + "Interval_Year", + "Interval_Day", + "UUID", + "Decimal", + "Precision_Timestamp", + "Precision_Timestamp_TZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Geometry", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] - ruleNames = [ "LineComment", "BlockComment", "Whitespace", "A", "B", - "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", - "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", - "Y", "Z", "DIGIT", "INTEGER", "If", "Then", "Else", "Boolean", - "I8", "I16", "I32", "I64", "FP32", "FP64", "String", "Binary", - "Timestamp", "Timestamp_TZ", "Date", "Time", "Interval_Year", - "Interval_Day", "UUID", "Decimal", "Precision_Timestamp", - "Precision_Timestamp_TZ", "FixedChar", "VarChar", "FixedBinary", - "Struct", "NStruct", "List", "Map", "ANY", "UserDefined", - "Geometry", "Bool", "Str", "VBin", "Ts", "TsTZ", "IYear", - "IDay", "Dec", "PTs", "PTsTZ", "FChar", "VChar", "FBin", - "DOUBLE_COLON", "IDENTIFIER", "O_ANGLE_BRACKET", "C_ANGLE_BRACKET", - "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "COMMA", "EQ", - "COLON", "QMARK", "HASH", "DOT" ] + ruleNames = [ + "LineComment", + "BlockComment", + "Whitespace", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "DIGIT", + "INTEGER", + "If", + "Then", + "Else", + "Boolean", + "I8", + "I16", + "I32", + "I64", + "FP32", + "FP64", + "String", + "Binary", + "Timestamp", + "Timestamp_TZ", + "Date", + "Time", + "Interval_Year", + "Interval_Day", + "UUID", + "Decimal", + "Precision_Timestamp", + "Precision_Timestamp_TZ", + "FixedChar", + "VarChar", + "FixedBinary", + "Struct", + "NStruct", + "List", + "Map", + "ANY", + "UserDefined", + "Geometry", + "Bool", + "Str", + "VBin", + "Ts", + "TsTZ", + "IYear", + "IDay", + "Dec", + "PTs", + "PTsTZ", + "FChar", + "VChar", + "FBin", + "DOUBLE_COLON", + "IDENTIFIER", + "O_ANGLE_BRACKET", + "C_ANGLE_BRACKET", + "OPAREN", + "CPAREN", + "OBRACKET", + "CBRACKET", + "COMMA", + "EQ", + "COLON", + "QMARK", + "HASH", + "DOT", + ] grammarFileName = "SubstraitLexer.g4" - def __init__(self, input=None, output:TextIO = sys.stdout): + def __init__(self, input=None, output: TextIO = sys.stdout): super().__init__(input, output) self.checkVersion("4.13.2") - self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._interp = LexerATNSimulator( + self, self.atn, self.decisionsToDFA, PredictionContextCache() + ) self._actions = None self._predicates = None - - diff --git a/tests/coverage/coverage.py b/tests/coverage/coverage.py index 12372565b..4f5c50a3e 100755 --- a/tests/coverage/coverage.py +++ b/tests/coverage/coverage.py @@ -24,7 +24,10 @@ def to_dict(self): return { "function_name": self.function_name, "test_count": self.test_count, - "variants": [{"signature": variant, "test_count": count} for variant, count in self.function_variant_coverage.items()] + "variants": [ + {"signature": variant, "test_count": count} + for variant, count in self.function_variant_coverage.items() + ], } @@ -49,7 +52,10 @@ def to_dict(self): return { "file_name": self.file_name, "test_count": self.test_count, - "function_coverage": [func_coverage.to_dict() for func_name, func_coverage in self.function_coverage.items()], + "function_coverage": [ + func_coverage.to_dict() + for func_name, func_coverage in self.function_coverage.items() + ], } @@ -83,7 +89,9 @@ def compute_coverage(self): def to_dict(self): return { - "file_coverage": [file_coverage.to_dict() for file_coverage in self.file_coverage.values()], + "file_coverage": [ + file_coverage.to_dict() for file_coverage in self.file_coverage.values() + ], "test_count": self.test_count, "num_covered_function_variants": self.num_covered_variants, "total_function_variants": self.total_variants, diff --git a/tests/coverage/extensions.py b/tests/coverage/extensions.py index 3aa53d312..d61cfca9c 100644 --- a/tests/coverage/extensions.py +++ b/tests/coverage/extensions.py @@ -24,10 +24,10 @@ def substrait_type_str(rule_num): def build_type_to_short_type(): rule_map = { - SubstraitLexer.I8: SubstraitLexer.I8, - SubstraitLexer.I16: SubstraitLexer.I16, - SubstraitLexer.I32: SubstraitLexer.I32, - SubstraitLexer.I64: SubstraitLexer.I64, + SubstraitLexer.I8: SubstraitLexer.I8, + SubstraitLexer.I16: SubstraitLexer.I16, + SubstraitLexer.I32: SubstraitLexer.I32, + SubstraitLexer.I64: SubstraitLexer.I64, SubstraitLexer.FP32: SubstraitLexer.FP32, SubstraitLexer.FP64: SubstraitLexer.FP64, SubstraitLexer.String: SubstraitLexer.Str, @@ -52,7 +52,9 @@ def build_type_to_short_type(): SubstraitLexer.ANY: SubstraitLexer.ANY, SubstraitLexer.Geometry: SubstraitLexer.Geometry, } - to_short_type = {substrait_type_str(k): substrait_type_str(v) for k, v in rule_map.items()} + to_short_type = { + substrait_type_str(k): substrait_type_str(v) for k, v in rule_map.items() + } any_type = substrait_type_str(SubstraitLexer.ANY) for i in range(1, 3): to_short_type[f"{any_type}{i}"] = f"{any_type}{i}" diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py index 0508a72a6..1ec5e2d15 100644 --- a/tests/coverage/test_coverage.py +++ b/tests/coverage/test_coverage.py @@ -40,7 +40,10 @@ def test_parse_date_time_example(): assert len(test_file.testcases) == 1 assert test_file.testcases[0].func_name == "lt" assert test_file.testcases[0].base_uri == "/extensions/functions_datetime.yaml" - assert test_file.testcases[0].group.name == "timestamp examples using the timestamp type" + assert ( + test_file.testcases[0].group.name + == "timestamp examples using the timestamp type" + ) assert test_file.testcases[0].result == CaseLiteral("true", "bool") assert test_file.testcases[0].args[0] == CaseLiteral("2016-12-31T13:30:15", "ts") assert test_file.testcases[0].args[1] == CaseLiteral("2017-12-31T13:30:15", "ts") diff --git a/tests/coverage/visitor.py b/tests/coverage/visitor.py index e6ae4720a..9a6a3e9ff 100644 --- a/tests/coverage/visitor.py +++ b/tests/coverage/visitor.py @@ -1,6 +1,8 @@ # SPDX-License-Identifier: Apache-2.0 from tests.coverage.antlr_parser.FuncTestCaseParser import FuncTestCaseParser -from tests.coverage.antlr_parser.FuncTestCaseParserVisitor import FuncTestCaseParserVisitor +from tests.coverage.antlr_parser.FuncTestCaseParserVisitor import ( + FuncTestCaseParserVisitor, +) from tests.coverage.nodes import ( CaseGroup, TestFile, diff --git a/tests/test_extensions.py b/tests/test_extensions.py index 3de4855c6..466667266 100644 --- a/tests/test_extensions.py +++ b/tests/test_extensions.py @@ -35,4 +35,3 @@ def test_build_type_to_short_type(): assert long_to_short["list"] == "list" assert long_to_short["map"] == "map" assert long_to_short["struct"] == "struct" - From 8ec50b529301da64ee096f255c4d0b5c8dfa87c6 Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Thu, 12 Sep 2024 20:10:54 +0530 Subject: [PATCH 16/19] fix to use specific imports --- tests/coverage/antlr_parser/FuncTestCaseLexer.py | 9 +++++++-- .../coverage/antlr_parser/FuncTestCaseParser.py | 16 ++++++++++++++-- .../antlr_parser/FuncTestCaseParserListener.py | 2 +- .../antlr_parser/FuncTestCaseParserVisitor.py | 2 +- tests/coverage/antlr_parser/SubstraitLexer.py | 9 +++++++-- tests/coverage/test_coverage.py | 1 - 6 files changed, 30 insertions(+), 9 deletions(-) diff --git a/tests/coverage/antlr_parser/FuncTestCaseLexer.py b/tests/coverage/antlr_parser/FuncTestCaseLexer.py index 2cee7d59a..b031cacbf 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseLexer.py +++ b/tests/coverage/antlr_parser/FuncTestCaseLexer.py @@ -1,6 +1,11 @@ # Generated from FuncTestCaseLexer.g4 by ANTLR 4.13.2 -from antlr4 import * -from io import StringIO +from antlr4 import ( + ATNDeserializer, + DFA, + Lexer, + LexerATNSimulator, + PredictionContextCache, +) import sys if sys.version_info[1] > 5: diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py index f5d17b2ff..843bd9bdd 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParser.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -1,7 +1,19 @@ # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 # encoding: utf-8 -from antlr4 import * -from io import StringIO +from antlr4 import ( + ATNDeserializer, + DFA, + NoViableAltException, + ParseTreeListener, + ParseTreeVisitor, + Parser, + ParserATNSimulator, + ParserRuleContext, + PredictionContextCache, + RecognitionException, + Token, + TokenStream, +) import sys if sys.version_info[1] > 5: diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py index 830474d71..f766f77e3 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py @@ -1,5 +1,5 @@ # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 -from antlr4 import * +from antlr4 import ParseTreeListener, ParseTreeVisitor if "." in __name__: from .FuncTestCaseParser import FuncTestCaseParser diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py index 062450e8a..ddfb4af72 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py @@ -1,5 +1,5 @@ # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 -from antlr4 import * +from antlr4 import ParseTreeVisitor if "." in __name__: from .FuncTestCaseParser import FuncTestCaseParser diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py index 0b426603e..fdd6f3dba 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.py +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -1,6 +1,11 @@ # Generated from SubstraitLexer.g4 by ANTLR 4.13.2 -from antlr4 import * -from io import StringIO +from antlr4 import ( + ATNDeserializer, + DFA, + Lexer, + LexerATNSimulator, + PredictionContextCache, +) import sys if sys.version_info[1] > 5: diff --git a/tests/coverage/test_coverage.py b/tests/coverage/test_coverage.py index 1ec5e2d15..f4d145dc0 100644 --- a/tests/coverage/test_coverage.py +++ b/tests/coverage/test_coverage.py @@ -25,7 +25,6 @@ def test_parse_basic_example(): add(120::i8, 10::i8) [overflow:ERROR] = """ - test_str = header + tests test_file = parse_string(header + tests) assert len(test_file.testcases) == 3 From 924f441a53311d1a4a915b4e4fc4c20a8722a86e Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Thu, 12 Sep 2024 20:25:44 +0530 Subject: [PATCH 17/19] licensing and lint errors --- .../antlr_parser/FuncTestCaseLexer.py | 1 + .../antlr_parser/FuncTestCaseParser.py | 26 +------------------ .../FuncTestCaseParserListener.py | 3 ++- .../antlr_parser/FuncTestCaseParserVisitor.py | 1 + tests/coverage/antlr_parser/SubstraitLexer.py | 1 + 5 files changed, 6 insertions(+), 26 deletions(-) diff --git a/tests/coverage/antlr_parser/FuncTestCaseLexer.py b/tests/coverage/antlr_parser/FuncTestCaseLexer.py index b031cacbf..7fb7e7df8 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseLexer.py +++ b/tests/coverage/antlr_parser/FuncTestCaseLexer.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from FuncTestCaseLexer.g4 by ANTLR 4.13.2 from antlr4 import ( ATNDeserializer, diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py index 843bd9bdd..a28fc8d1a 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParser.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 # encoding: utf-8 from antlr4 import ( @@ -5980,7 +5981,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class DateContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6005,7 +6005,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class StringContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6030,7 +6029,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I64Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6055,7 +6053,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class UserDefinedContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6083,7 +6080,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I32Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6108,7 +6104,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class IntervalYearContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6133,7 +6128,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class UuidContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6158,7 +6152,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I8Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6183,7 +6176,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class I16Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6208,7 +6200,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class BinaryContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6233,7 +6224,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class IntervalDayContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6258,7 +6248,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class Fp64Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6283,7 +6272,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class Fp32Context(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6308,7 +6296,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class TimeContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6333,7 +6320,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class BooleanContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6358,7 +6344,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class TimestampContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6383,7 +6368,6 @@ def accept(self, visitor: ParseTreeVisitor): return visitor.visitChildren(self) class TimestampTzContext(ScalarTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.ScalarTypeContext @@ -6532,7 +6516,6 @@ def scalarType(self): class FixedCharTypeContext(ParserRuleContext): __slots__ = "parser" - def __init__( self, parser, parent: ParserRuleContext = None, invokingState: int = -1 ): @@ -6546,7 +6529,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class FixedCharContext(FixedCharTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.FixedCharTypeContext @@ -6633,7 +6615,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class VarCharContext(VarCharTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.VarCharTypeContext @@ -6720,7 +6701,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class FixedBinaryContext(FixedBinaryTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.FixedBinaryTypeContext @@ -6809,7 +6789,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class DecimalContext(DecimalTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.DecimalTypeContext @@ -6914,7 +6893,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class PrecisionTimestampContext(PrecisionTimestampTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.PrecisionTimestampTypeContext @@ -6989,7 +6967,6 @@ def precisionTimestampType(self): class PrecisionTimestampTZTypeContext(ParserRuleContext): __slots__ = "parser" - def __init__( self, parser, parent: ParserRuleContext = None, invokingState: int = -1 ): @@ -7003,7 +6980,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class PrecisionTimestampTZContext(PrecisionTimestampTZTypeContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.PrecisionTimestampTZTypeContext diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py index f766f77e3..336e750b5 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserListener.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserListener.py @@ -1,5 +1,6 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 -from antlr4 import ParseTreeListener, ParseTreeVisitor +from antlr4 import ParseTreeListener if "." in __name__: from .FuncTestCaseParser import FuncTestCaseParser diff --git a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py index ddfb4af72..18eca41c5 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParserVisitor.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from FuncTestCaseParser.g4 by ANTLR 4.13.2 from antlr4 import ParseTreeVisitor diff --git a/tests/coverage/antlr_parser/SubstraitLexer.py b/tests/coverage/antlr_parser/SubstraitLexer.py index fdd6f3dba..bb6a256c8 100644 --- a/tests/coverage/antlr_parser/SubstraitLexer.py +++ b/tests/coverage/antlr_parser/SubstraitLexer.py @@ -1,3 +1,4 @@ +# SPDX-License-Identifier: Apache-2.0 # Generated from SubstraitLexer.g4 by ANTLR 4.13.2 from antlr4 import ( ATNDeserializer, From 5a36340777a78a06ce41b157ea5482cabcfc750d Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Thu, 12 Sep 2024 21:04:43 +0530 Subject: [PATCH 18/19] fix few more lint errors --- tests/coverage/antlr_parser/FuncTestCaseParser.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/coverage/antlr_parser/FuncTestCaseParser.py b/tests/coverage/antlr_parser/FuncTestCaseParser.py index a28fc8d1a..70cd413c9 100644 --- a/tests/coverage/antlr_parser/FuncTestCaseParser.py +++ b/tests/coverage/antlr_parser/FuncTestCaseParser.py @@ -6516,6 +6516,7 @@ def scalarType(self): class FixedCharTypeContext(ParserRuleContext): __slots__ = "parser" + def __init__( self, parser, parent: ParserRuleContext = None, invokingState: int = -1 ): @@ -6967,6 +6968,7 @@ def precisionTimestampType(self): class PrecisionTimestampTZTypeContext(ParserRuleContext): __slots__ = "parser" + def __init__( self, parser, parent: ParserRuleContext = None, invokingState: int = -1 ): @@ -7169,7 +7171,6 @@ def copyFrom(self, ctx: ParserRuleContext): super().copyFrom(ctx) class IntegerLiteralContext(NumericParameterContext): - def __init__( self, parser, ctx: ParserRuleContext ): # actually a FuncTestCaseParser.NumericParameterContext From 0f672bca1e14c9c1e6b4e8d83947e8cae5f15709 Mon Sep 17 00:00:00 2001 From: Chandra Sanapala Date: Thu, 12 Sep 2024 21:21:59 +0530 Subject: [PATCH 19/19] Add check-substrait-extensions to pre-commit --- .pre-commit-config.yaml | 8 ++++++++ tests/test_extensions.py | 7 ++++++- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d30e95a5c..4c1098741 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -21,3 +21,11 @@ repos: rev: 6.1.0 hooks: - id: flake8 +- repo: local + hooks: + - id: check-substrait-extensions + name: Check Substrait extensions + entry: pytest tests/test_extensions.py::test_read_substrait_extensions + language: python + pass_filenames: false + diff --git a/tests/test_extensions.py b/tests/test_extensions.py index 466667266..3cb7e5294 100644 --- a/tests/test_extensions.py +++ b/tests/test_extensions.py @@ -1,11 +1,16 @@ # SPDX-License-Identifier: Apache-2.0 +import os + from tests.coverage.extensions import build_type_to_short_type +# NOTE: this test is run as part of pre-commit hook def test_read_substrait_extensions(): from tests.coverage.extensions import Extension - registry = Extension.read_substrait_extensions("../extensions") + current_dir = os.path.dirname(os.path.abspath(__file__)) + extensions_path = os.path.join(current_dir, "../extensions") + registry = Extension.read_substrait_extensions(extensions_path) assert len(registry.registry) >= 161 num_overloads = sum([len(f) for f in registry.registry.values()]) assert num_overloads >= 510